@namzu/sdk 36.0.0 → 37.0.0

package/src/runtime/query/iteration/phases/advisory.ts

@@ -5,6 +5,7 @@ import { toolResultToText } from '../../../../types/message/content.js'
 import { createRuntimeContextMessage } from '../../../../types/message/index.js'
 import type { ChatCompletionResponse } from '../../../../types/provider/index.js'
 import { toErrorMessage } from '../../../../utils/error.js'
+import { activeContextWindow, measureContext } from './compaction.js'
 import type { IterationContext } from './context.js'
 
 function countToolCalls(ctx: IterationContext): number {
@@ -18,9 +19,8 @@ function countToolCalls(ctx: IterationContext): number {
 }
 
 function estimateContextWindowPercent(ctx: IterationContext): number {
-	const budget = ctx.runConfig.tokenBudget
-	if (budget <= 0) return 0
-	return (ctx.runMgr.tokenUsage.totalTokens / budget) * 100
+	const window = activeContextWindow(ctx)
+	return (measureContext(ctx).tokens / window.tokens) * 100
 }
 
 function computeCostBudgetPercent(ctx: IterationContext): number | undefined {
@@ -67,7 +67,7 @@ export async function runAdvisoryPhase(
 		contextWindowPercent: estimateContextWindowPercent(ctx),
 		totalCostUsd: ctx.runMgr.costInfo.totalCost,
 		costBudgetPercent: computeCostBudgetPercent(ctx),
-		lastError: extractLastErrorFromMessages(ctx),
+		lastError: extractCurrentToolErrors(ctx, response),
 		lastToolCategory: extractLastToolCategory(ctx, response),
 		advisoryCallCount: advisoryCtx.callHistory.length,
 	}
@@ -190,16 +190,26 @@ export async function runAdvisoryPhase(
 	}
 }
 
-function extractLastErrorFromMessages(ctx: IterationContext): string | undefined {
+function extractCurrentToolErrors(
+	ctx: IterationContext,
+	response: ChatCompletionResponse,
+): string | undefined {
+	const calls = new Map(response.message.toolCalls?.map((call) => [call.id, call.function.name]))
+	if (calls.size === 0) return undefined
 	const messages = ctx.runMgr.messages
+	const errors: string[] = []
 	for (let i = messages.length - 1; i >= 0; i--) {
 		const msg = messages[i]
-		if (msg?.role === 'tool') {
-			// Tool results can now carry content blocks; the error sentinel is
-			// a text convention, so flatten before matching it.
-			const text = toolResultToText(msg.content)
-			if (text.startsWith('Error:')) return text
+		// The current assistant turn starts this batch. Never resurrect an old
+		// failure, even if a provider reused a call ID in another iteration.
+		if (msg?.role === 'assistant') break
+		if (msg?.role === 'tool' && msg.isError === true && calls.has(msg.toolCallId)) {
+			errors.push(
+				toolResultToText(msg.content).trim() ||
+					`Tool ${calls.get(msg.toolCallId)} reported an error.`,
+			)
 		}
 	}
-	return undefined
+	// A successful sibling does not erase failed results in this same batch.
+	return errors.length > 0 ? errors.reverse().join('\n') : undefined
 }

package/src/runtime/query/iteration/phases/compaction.ts

@@ -28,6 +28,16 @@ import { isWorkingMemoryMessage } from './working-memory.js'
 // because `runtime/query/index.ts` already imports it from this path.
 export { isCompactionMessage } from '../../../../compaction/summary.js'
 
+/** The selected request model owns the denominator, including overflow recovery. */
+export function activeContextWindow(ctx: IterationContext) {
+	const model = ctx.contextModel ?? ctx.runConfig.model
+	return resolveContextWindow(
+		ctx.compactionConfig?.contextWindowTokens,
+		model,
+		model === ctx.runConfig.model ? ctx.providerContextWindow : ctx.activeProviderContextWindow,
+	)
+}
+
 /**
  * How much a forced pass must shed before the turn is worth retrying.
  *
@@ -147,7 +157,12 @@ async function commitToolResultClear(
 	plan: ToolResultClearPlan,
 	contextWindowTokens: number,
 	windowSource: 'config' | 'provider' | 'model-table' | 'default',
+	reason: 'threshold' | 'overflow',
 ): Promise<void> {
+	// A shorter replacement also removes evidence. Preserve its original
+	// content in the same archive used by whole-message compaction before
+	// changing the live history or publishing the clear.
+	await recordShed(ctx, [...ctx.runMgr.messages], plan.messages, reason)
 	installMessages(ctx.runMgr.messages, plan.messages)
 	// The provider counted the pre-edit prompt. Leaving that measurement live
 	// makes the next trigger compare the old prompt against the new history.
@@ -547,11 +562,7 @@ async function runCompactionCheckInner(
 	// number. Nothing in the estate ever set `contextWindowTokens`, so the
 	// fallback WAS the behavior, and the shipped CLI's 1M budget put the
 	// trigger at ~700k. See `compaction/context-window.ts`.
-	const window = resolveContextWindow(
-		config.contextWindowTokens,
-		ctx.runConfig.model,
-		ctx.providerContextWindow,
-	)
+	const window = activeContextWindow(ctx)
 	const budget = window.tokens
 
 	const usage = estimatedTokens / budget
@@ -659,7 +670,7 @@ async function runCompactionCheckInner(
 			...(openTasks ? { openTasks } : {}),
 		})
 		if (working.reclaimedTokens > 0) {
-			await commitToolResultClear(ctx, working, budget, window.source)
+			await commitToolResultClear(ctx, working, budget, window.source, pass.reason)
 		}
 		// Under the trigger, the working set was the whole pass: the summary
 		// path is for the trigger, not for the soft target.
@@ -684,7 +695,7 @@ async function runCompactionCheckInner(
 		// the NEXT turn will correct it, and an over-eager summarization is
 		// far more costly than one late pass.
 		if (clearPlan.reliefWasEnough) {
-			await commitToolResultClear(ctx, clearPlan, budget, window.source)
+			await commitToolResultClear(ctx, clearPlan, budget, window.source, pass.reason)
 			return
 		}
 	}
@@ -736,7 +747,7 @@ async function runCompactionCheckInner(
 		// There is no opaque provider wait on this path, so publish that single
 		// complete edit now rather than discarding it.
 		if (stagedClear) {
-			await commitToolResultClear(ctx, stagedClear, budget, window.source)
+			await commitToolResultClear(ctx, stagedClear, budget, window.source, pass.reason)
 		}
 		return
 	}
@@ -823,6 +834,20 @@ async function runCompactionCheckInner(
 
 	const live = ctx.runMgr.messages
 	const oldCount = live.length
+	// Retained history can survive in full while a summary adds another copy
+	// of its facts. Even an unretained span may be smaller than the cumulative
+	// summary. Compare both candidates with the same estimator, rather than
+	// comparing provider usage against an estimate or trusting message count.
+	// When a clear was staged, require the summary itself to improve on it;
+	// otherwise publish the useful clear without consuming its savings.
+	if (estimateMessagesTokens(newMessages) >= estimateMessagesTokens(messages)) {
+		if (stagedClear && stagedClear.reclaimedTokens > 0) {
+			await commitToolResultClear(ctx, stagedClear, budget, window.source, pass.reason)
+		} else {
+			await declined(ctx, 'shed_nothing', oldCount)
+		}
+		return
+	}
 	await recordShed(ctx, [...live], newMessages, options?.force ? 'overflow' : 'threshold')
 
 	installMessages(live, newMessages)
@@ -840,12 +865,9 @@ async function runCompactionCheckInner(
 	// edits are installed and no verifier can still fail between them.
 	if (stagedClear) await emitToolResultClear(ctx, stagedClear)
 
-	// Hysteresis. A pass that only gets the context from 0.72 to 0.71 of the
-	// window leaves the trigger armed, so the next iteration compacts again
-	// — paying a summarization call and busting the prompt-cache prefix each
-	// time, for nothing. Report the shortfall rather than repeating a move
-	// that demonstrably does not work; `resetThreshold` was declared and
-	// CLI-set but read by nothing until now.
+	// Report remaining pressure after a useful edit. This diagnostic does not
+	// suppress future passes: appended evidence may become reclaimable even
+	// when the protected floor and recent history remain above the target.
 	const reachedReset = newEstimate / budget <= config.resetThreshold
 	if (!reachedReset) {
 		ctx.log.warn('Compaction did not reach its reset threshold — context may still be tight', {

package/src/runtime/query/iteration/phases/context.ts

@@ -131,6 +131,8 @@ export interface IterationContext {
 	 * drained and no tool result is extended.
 	 */
 	readonly steering?: SteeringChannel
+	/** Records operator intent only after guidance was accepted by a tool result. */
+	readonly onSteeringDelivered?: (text: string) => void
 	/** Exit notices for the run's background jobs, drained into the next tool result. */
 	readonly jobNotices?: SteeringChannel
 	readonly checkpointMgr: CheckpointManager
@@ -179,6 +181,11 @@ export interface IterationContext {
 	 * through to the table.
 	 */
 	readonly providerContextWindow?: number
+	/** Selected request model; its window must not reuse another model's metadata. */
+	contextModel?: string
+	activeProviderContextWindow?: number
+	/** Bounded, run-cached provider metadata lookup for a newly selected model. */
+	readonly resolveModelContextWindow?: (model: string) => Promise<number | undefined>
 
 	/**
 	 * Text queued for this run since its last turn.
@@ -188,6 +195,8 @@ export interface IterationContext {
 	 * after tool results and before the next turn.
 	 */
 	readonly inboundMessages?: () => readonly import('../../../../types/message/index.js').Message[]
+	/** Known topic-queue arrivals appended after the restored checkpoint history. */
+	readonly resumedInput?: readonly import('../../../../types/message/index.js').Message[]
 	/** Observes pending input without draining it; abort releases the waiter. */
 	readonly waitForInbound?: (signal: AbortSignal) => Promise<void>
 

package/src/runtime/query/iteration/phases/tool-review.ts

@@ -146,7 +146,11 @@ export async function* runToolReview(
 		// user message wedged between them is rejected by the provider. Same
 		// delivery a denial already uses, without the refusal.
 		for (const msg of attachRepeatNotice(
-			attachNotice(attachSteering(batch.messages, ctx.steering), ctx.jobNotices, formatJobNote),
+			attachNotice(
+				attachSteering(batch.messages, ctx.steering, ctx.onSteeringDelivered),
+				ctx.jobNotices,
+				formatJobNote,
+			),
 			notices,
 		)) {
 			ctx.runMgr.pushMessage(msg)

package/src/runtime/query/iteration/phases/working-memory.ts

@@ -14,6 +14,10 @@ import type { IterationContext } from './context.js'
 export const WORKING_MEMORY_HEADER =
 	'[WORKING MEMORY] Authoritative state for this conversation — you produced these.'
 
+// Stored in the message, so ownership survives checkpoint JSON. Unmarked
+// inherited blocks may be opaque host ledgers and must never be guessed away.
+const TOOL_PINS_HEADER = `${WORKING_MEMORY_HEADER}\n[Tool-managed pins]`
+
 /**
  * True when `content` is the pinned working-memory slot (header identity only).
  * Shared with `compaction.ts` so the survival guard re-pins by the SAME rule.
@@ -34,16 +38,15 @@ export function isWorkingMemoryMessage(content: string | null | undefined): bool
  *
  * Failure-isolated (the `web-search` seam rule): a throwing/slow provider
  * degrades to "no refresh this turn" (keeps the prior slot), never breaks the
- * run. Early-returns when no provider is configured ⇒ byte-identical run path.
+ * run. With no provider or tool-owned slot, the history is left unchanged.
  */
 export async function refreshWorkingMemory(ctx: IterationContext): Promise<void> {
 	const provider = ctx.workingMemoryProvider
 	// What the tools pinned joins the slot beside what the host provides: a
 	// pin exists to be in front of the model every iteration, and until this
 	// the working state reached the history only through a compaction
-	// summary. No provider and no pins leaves the history untouched.
+	// summary. When the final pin is removed, retire only a tool-owned slot.
 	const pinned = ctx.workingStateManager ? renderPins(ctx.workingStateManager.getState()) : null
-	if (!provider && !pinned) return
 
 	let block = ''
 	if (provider) {
@@ -80,17 +83,32 @@ export async function refreshWorkingMemory(ctx: IterationContext): Promise<void>
 		}
 	}
 
+	if (!provider && !pinned) {
+		if (!ctx.workingStateManager) return
+		const prior = msgs[idx]?.content
+		if (typeof prior !== 'string' || !prior.startsWith(TOOL_PINS_HEADER)) return
+	}
+
 	if (!block.trim()) {
 		// Empty block ⇒ remove the slot (byte-identical-when-empty).
-		if (idx >= 0) msgs.splice(idx, 1)
+		if (idx >= 0) {
+			msgs.splice(idx, 1)
+			ctx.runMgr.clearLastPromptTokens?.()
+		}
 		return
 	}
 
-	const wm = createSystemMessage(`${WORKING_MEMORY_HEADER}\n\n${block}`, 'ephemeral')
+	const header = provider ? WORKING_MEMORY_HEADER : TOOL_PINS_HEADER
+	const content = `${header}\n\n${block}`
+	if (idx >= 0 && msgs[idx]?.content === content) return
+	const wm = createSystemMessage(content, 'ephemeral')
 	if (idx >= 0) {
 		msgs[idx] = wm
 	} else {
 		// Insert as the LAST leading system message (after static + dynamic).
 		msgs.splice(leadEnd, 0, wm)
 	}
+	// The old provider reading measured a different prefix, and an insertion
+	// also moves its tail watermark. Re-estimate until the next request reports.
+	ctx.runMgr.clearLastPromptTokens?.()
 }

package/src/runtime/query/iteration/stream-turn.ts

@@ -1,4 +1,5 @@
 import { type Span, SpanStatusCode } from '@opentelemetry/api'
+import { assertNativeStructuredOutputSupported } from '../../../provider/capabilities.js'
 import { isProviderRequestError } from '../../../provider/errors.js'
 import { GENAI, NAMZU, chatSpanName, parentContext } from '../../../telemetry/attributes.js'
 import {
@@ -153,6 +154,7 @@ export async function* streamProviderTurn(
 		readonly onAccepted: (identity: RequestImageIdentity) => Promise<void>
 	},
 ): AsyncGenerator<RunEvent, StreamingTurnResult> {
+	assertNativeStructuredOutputSupported(provider, params)
 	// The `chat {model}` span the GenAI conventions require. There was none:
 	// `chatSpanName` existed with zero call sites, so a trace carried no LLM
 	// latency at all and the token counts landed on the iteration span

package/src/runtime/query/steering.ts

@@ -1,4 +1,15 @@
-import type { Message } from '../../types/message/index.js'
+import type { Message, UserMessage } from '../../types/message/index.js'
+
+/** User-role runtime reports are context, not new operator intent. */
+export function isOperatorUserMessage(message: Message): message is UserMessage {
+	if (message.role !== 'user') return false
+	const source = message.source
+	return (
+		!source ||
+		source.type === 'goal-round' ||
+		(source.type === 'runtime-context' && source.kind === 'steering')
+	)
+}
 
 /**
  * Guidance a host hands to a turn that is already running.
@@ -134,6 +145,8 @@ export function formatSteeringNote(text: string): string {
 export function attachSteering(
 	messages: readonly Message[],
 	channel: SteeringChannel | undefined,
+	/** Receives accepted operator text, never inferred from a tool's output. */
+	onDelivered?: (text: string) => void,
 ): readonly Message[] {
 	if (!channel?.pending) return messages
 
@@ -162,6 +175,10 @@ export function attachSteering(
 	}
 
 	const next = [...messages]
-	next[lastToolIndex] = { ...target, content: target.content + formatSteeringNote(guidance) }
+	next[lastToolIndex] = {
+		...target,
+		content: target.content + formatSteeringNote(guidance),
+	}
+	onDelivered?.(guidance)
 	return next
 }

package/src/runtime/query/tool-call-budget.ts

@@ -0,0 +1,115 @@
+import type { RunId } from '../../types/ids/index.js'
+import type { RunEvent } from '../../types/run/index.js'
+
+export function assertMaxToolCalls(limit: number | undefined): void {
+	if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 0)) {
+		throw new RangeError('maxToolCalls must be a nonnegative safe integer.')
+	}
+}
+
+/** A run-owned admission ledger; durability belongs to the run's event store. */
+export class ToolCallBudget {
+	private used = 0
+	private initialized?: Promise<void>
+	private chain: Promise<void> = Promise.resolve()
+	private failed: unknown
+
+	constructor(
+		private readonly limit: number,
+		private readonly runId: RunId,
+		private readonly emit: (event: RunEvent) => Promise<void>,
+		private readonly read?: () => Promise<readonly RunEvent[]>,
+	) {
+		assertMaxToolCalls(limit)
+	}
+
+	private async initialize(): Promise<void> {
+		const events = (await this.read?.()) ?? []
+		if (events.length > 100_000) throw new Error('Tool-call budget recovery exceeds 100000 events.')
+		let initialized = false
+		let expectedSeq = 0
+		for (const event of events) {
+			// A replayed transcript must be complete and belong to this run.
+			if (event.runId !== this.runId || event.seq !== ++expectedSeq)
+				throw new Error('Tool-call budget recovery requires a complete run event log.')
+			if (event.type === 'tool_calls_admitted') {
+				if (
+					!Number.isSafeInteger(event.count) ||
+					event.count < 0 ||
+					!Number.isSafeInteger(event.used) ||
+					event.used !== this.used + event.count ||
+					!Number.isSafeInteger(event.limit) ||
+					event.limit < event.used ||
+					!['initialize', 'batch', 'nested', 'retry'].includes(event.kind) ||
+					(event.kind === 'initialize'
+						? initialized || event.count !== 0
+						: !initialized || event.count === 0)
+				)
+					throw new Error('Invalid tool-call admission ledger.')
+				initialized = true
+				this.used = event.used
+			} else if (
+				!initialized &&
+				(event.type === 'tool_executing' || event.type === 'tool_completed')
+			) {
+				throw new Error('Cannot establish tool-call usage for an earlier unbudgeted execution.')
+			}
+		}
+		if (!initialized) {
+			await this.emit({
+				type: 'tool_calls_admitted',
+				runId: this.runId,
+				kind: 'initialize',
+				count: 0,
+				used: 0,
+				limit: this.limit,
+			})
+		}
+	}
+
+	/** Reserve before work, never refund. A refused group consumes no new slots. */
+	async admit(
+		count: number,
+		kind: 'batch' | 'nested' | 'retry',
+		signal: AbortSignal,
+	): Promise<string | undefined> {
+		signal.throwIfAborted()
+		const previous = this.chain
+		let release!: () => void
+		this.chain = new Promise<void>((resolve) => {
+			release = resolve
+		})
+		try {
+			await previous
+			signal.throwIfAborted()
+			if (this.failed !== undefined) throw this.failed
+			this.initialized ??= this.initialize()
+			await this.initialized
+			signal.throwIfAborted()
+			if (count > Math.max(0, this.limit - this.used)) {
+				return `Tool-call budget exhausted: this ${kind} needs ${count} slots; ${Math.max(0, this.limit - this.used)} remain of maxToolCalls=${this.limit}. No calls in this admission were executed.`
+			}
+			if (count === 0) return undefined
+			const used = this.used + count
+			try {
+				await this.emit({
+					type: 'tool_calls_admitted',
+					runId: this.runId,
+					kind,
+					count,
+					used,
+					limit: this.limit,
+				})
+			} catch (error) {
+				// An uncertain write must not be retried as a fresh allowance.
+				this.failed = error ?? new Error('Tool-call admission persistence failed.')
+				throw this.failed
+			}
+			this.used = used
+			signal.throwIfAborted()
+			return undefined
+		} finally {
+			release()
+		}
+	}
+}

package/src/runtime/query/tooling.ts

@@ -43,6 +43,8 @@ export interface ToolingBootstrapConfig {
 	web?: import('../../types/tool/index.js').ToolContext['web']
 	toolRetryBackoff?: Partial<BackoffPolicy>
 	maxToolConcurrency?: number
+	maxToolCalls?: number
+	readToolCallBudgetEvents?: () => Promise<readonly RunEvent[]>
 	maxToolOutputChars?: number
 	maxToolContentBytes?: number
 	toolOutputDir?: string
@@ -84,6 +86,10 @@ export class ToolingBootstrap {
 				...(config.toolRetryBackoff !== undefined
 					? { toolRetryBackoff: config.toolRetryBackoff }
 					: {}),
+				...(config.maxToolCalls !== undefined ? { maxToolCalls: config.maxToolCalls } : {}),
+				...(config.readToolCallBudgetEvents
+					? { readToolCallBudgetEvents: config.readToolCallBudgetEvents }
+					: {}),
 				...(config.maxToolConcurrency !== undefined
 					? { maxToolConcurrency: config.maxToolConcurrency }
 					: {}),

package/src/scheduler/local.ts

@@ -111,6 +111,7 @@ export class LocalTaskScheduler implements TaskScheduler {
 		const task = await this.agentManager.sendMessage(
 			{
 				agentId: options.agentId,
+				beforeStart: options.beforeStart,
 				input: {
 					messages: [createUserMessage(options.prompt)],
 					workingDirectory: options.workingDirectory,

package/src/session/handoff/capacity.ts

@@ -62,7 +62,7 @@ export interface CapacityValidator {
 	): Promise<void>
 
 	/**
-	 * Asserts `existingDirectChildren + pendingNewChildren ≤ projectMaxWidth`
+	 * Asserts `liveDirectChildren + pendingNewChildren ≤ projectMaxWidth`
 	 * under `parentSessionId`. The width cap applies to a single spawn call —
 	 * a broadcast of N recipients passes `pendingNewChildren = N`.
 	 */
@@ -77,7 +77,7 @@ export interface CapacityValidator {
 /**
  * Default validator backed by {@link SessionStore}. Uses `getAncestry` for
  * depth (root-to-self chain length) and `getChildren` for width (count of
- * existing direct sub-sessions).
+ * pending or active direct sub-sessions). Historical edges stay queryable.
  */
 export class DefaultCapacityValidator implements CapacityValidator {
 	constructor(private readonly store: SessionStore) {}
@@ -108,7 +108,11 @@ export class DefaultCapacityValidator implements CapacityValidator {
 		tenantId: TenantId,
 	): Promise<void> {
 		const existing = await this.store.getChildren(parentSessionId, tenantId)
-		const total = existing.length + pendingNewChildren
+		const live = existing.filter(
+			(child) =>
+				child.status !== 'idle' && child.status !== 'failed' && child.status !== 'archived',
+		)
+		const total = live.length + pendingNewChildren
 		if (total > projectMaxWidth) {
 			throw new DelegationCapacityExceeded({
 				dimension: 'width',

package/src/store/memory/disk.ts

@@ -6,16 +6,24 @@ import type {
 	CreateMemoryParams,
 	MemoryContent,
 	MemoryIndexEntry,
+	MemoryRecord,
 	MemorySearchParams,
 	MemorySearchResult,
 	MemoryStore,
+	UpdateMemoryParams,
 } from '../../types/memory/index.js'
+import { assertMemoryStatus } from '../../types/memory/index.js'
 import { generateMemoryId, isEntityId } from '../../utils/id.js'
 import { SCOPE_ATTRIBUTE } from '../../utils/log/types.js'
 import { type Logger, resolveLogger } from '../../utils/logger.js'
 import { DiskRecordStore } from '../kv/record-store.js'
 import { defineSchema } from '../schema.js'
-import { InMemoryMemoryIndex } from './index.js'
+import { InMemoryMemoryIndex, searchMemoryEntries } from './index.js'
+import {
+	DEFAULT_MEMORY_LOCK_TIMEOUT_MS,
+	acquireMemoryOperationLock,
+	validateMemoryLockTimeout,
+} from './operation-lock.js'
 
 /**
  * This store's on-disk format, versioned as a unit — which is how a
@@ -32,27 +40,6 @@ interface StorageLocation {
 	readonly contentDir: string
 }
 
-const operationTails = new Map<string, Promise<void>>()
-
-/** Serialize every operation over one canonical disk projection in this process. */
-async function withMemoryOperationLock<T>(key: string, operation: () => Promise<T>): Promise<T> {
-	const previous = operationTails.get(key) ?? Promise.resolve()
-	let release = () => {}
-	const current = new Promise<void>((resolveCurrent) => {
-		release = resolveCurrent
-	})
-	const tail = previous.then(() => current)
-	operationTails.set(key, tail)
-
-	await previous
-	try {
-		return await operation()
-	} finally {
-		release()
-		if (operationTails.get(key) === tail) operationTails.delete(key)
-	}
-}
-
 function invalidIndex(
 	reason: string,
 	details: { entryIndex?: number; field?: string } = {},
@@ -163,11 +150,14 @@ function assertMemoryContent(value: unknown, expectedId: MemoryId): asserts valu
 export interface DiskMemoryStoreConfig {
 	baseDir: string
 	logger?: Logger
+	/** Maximum wait for another process's operation; default 10 seconds. Never breaks stale locks. */
+	lockTimeoutMs?: number
 }
 
 export class DiskMemoryStore implements MemoryStore {
 	private readonly baseDir: string
 	private readonly log: Logger
+	private readonly lockTimeoutMs: number
 	private readonly index = new InMemoryMemoryIndex()
 	private location?: StorageLocation
 	// Two instances of one primitive rather than two copies of its body.
@@ -180,6 +170,8 @@ export class DiskMemoryStore implements MemoryStore {
 	constructor(config: DiskMemoryStoreConfig) {
 		this.baseDir = join(config.baseDir, 'memory')
 		this.log = resolveLogger(config.logger).child({ [SCOPE_ATTRIBUTE]: 'store/memory/disk' })
+		this.lockTimeoutMs = config.lockTimeoutMs ?? DEFAULT_MEMORY_LOCK_TIMEOUT_MS
+		validateMemoryLockTimeout(this.lockTimeoutMs)
 	}
 
 	private get contentDir(): string {
@@ -235,10 +227,16 @@ export class DiskMemoryStore implements MemoryStore {
 		operation: (location: StorageLocation) => Promise<T>,
 	): Promise<T> {
 		const location = await this.storageLocation()
-		return withMemoryOperationLock(location.indexPath, async () => {
+		const release = await acquireMemoryOperationLock(
+			join(dirname(location.indexPath), 'operation.lock'),
+			this.lockTimeoutMs,
+		)
+		try {
 			await this.reloadIndex(location)
-			return operation(location)
-		})
+			return await operation(location)
+		} finally {
+			await release()
+		}
 	}
 
 	private async readContent(location: StorageLocation, id: MemoryId): Promise<MemoryContent> {
@@ -307,10 +305,17 @@ export class DiskMemoryStore implements MemoryStore {
 		})
 	}
 
-	async update(
-		id: MemoryId,
-		updates: Partial<CreateMemoryParams>,
-	): Promise<MemoryIndexEntry | undefined> {
+	async getRecord(id: MemoryId): Promise<MemoryRecord | undefined> {
+		return this.withAuthoritativeIndex(async (location) => {
+			assertStorageMemoryId(id, (reason) => invalidContent(id, reason, { field: 'id' }))
+			const entry = this.index.getEntry(id)
+			if (!entry) return undefined
+			return structuredClone({ entry, content: await this.readContent(location, id) })
+		})
+	}
+
+	async update(id: MemoryId, updates: UpdateMemoryParams): Promise<MemoryIndexEntry | undefined> {
+		if (updates.status !== undefined) assertMemoryStatus(updates.status)
 		return this.withAuthoritativeIndex(async (location) => {
 			assertStorageMemoryId(id, (reason) => invalidContent(id, reason, { field: 'id' }))
 			const existing = this.index.getEntry(id)
@@ -321,6 +326,7 @@ export class DiskMemoryStore implements MemoryStore {
 				title: updates.title ?? existing.title,
 				summary: updates.summary ?? existing.summary,
 				tags: updates.tags ? [...updates.tags] : existing.tags,
+				status: updates.status ?? existing.status,
 				updatedAt: Date.now(),
 			}
 			const updatesContent =
@@ -367,7 +373,23 @@ export class DiskMemoryStore implements MemoryStore {
 	}
 
 	async list(params?: MemorySearchParams): Promise<MemorySearchResult> {
-		return this.withAuthoritativeIndex(async () => this.index.search(params ?? {}))
+		return this.withAuthoritativeIndex(async (location) => {
+			if (!params?.query?.trim() && !params?.requiredIdentifiers?.length)
+				return this.index.search(params ?? {})
+			// Search the current bodies inside the same operation as the index
+			// snapshot. No retained cache can hide another process's update.
+			const candidates = this.index.search({
+				...params,
+				query: undefined,
+				limit: undefined,
+				requiredIdentifiers: undefined,
+			})
+			const contents = new Map<MemoryId, string>()
+			for (const entry of candidates.entries) {
+				contents.set(entry.id, (await this.readContent(location, entry.id)).content)
+			}
+			return searchMemoryEntries(candidates.entries, params, (id) => contents.get(id) ?? '')
+		})
 	}
 
 	getIndex(): InMemoryMemoryIndex {