kiokuko-dsh 0.2.8 → 0.2.9

package/dist/dsh/core/host.js

@@ -1,3 +1,6 @@
+import { nativeExecutionOwnership } from '../native-execution-ownership.js';
+import { NativeTaskAuthority } from '../native-task-authority.js';
+import { readOwnedIdentity } from '../owned-read-owner.js';
 import { MemoryRequestFence, MemorySnapshotStale } from '../memory-request-fence.js';
 import { retainedEvents } from '../context-projection.js';
 import { readAkinatorSession, readRunIntakeLink } from '../../akinator/store.js';
@@ -7,6 +10,9 @@ import { DshAnswerContext } from '../answer-context.js';
 import { IntakeModeConfig } from '../intake-mode.js';
 import { isNativeSubagent } from '../native-subagent.js';
 import { OnDemandIntake } from '../on-demand-intake.js';
+import { DshTaskWorkflow, TASK_STATE_EVENT, TASK_WORKFLOW_SERVICE } from '../task-state-host.js';
+import { mountTaskWorkflowSurface } from '../task-state-surface.js';
+import { findSessionTask, recordTaskUnresolved, readTaskSnapshot, clearTaskUnresolved, authorizeTaskLease, captureTaskLease, taskCanExecute } from '../task-state.js';
 import { readExecutionOwner } from '../orchestration/execution-owner.js';
 import { KiokukoError } from '../../errors.js';
 import { ObservationPackConfig } from '../observation-pack/policy.js';
@@ -26,7 +32,7 @@ import { mountModelAutoCommand } from '../model-auto/command.js';
 import { nativeModelCatalog } from '../native-model-catalog.js';
 import { installDshModelRouting } from '../model-routing.js';
 import { attachmentTypesFromMessages, nativeContextTokens, projectModelBinding } from '../model-auto/policy.js';
-import { LISP_CODING_SERVICE } from '../lisp-service-key.js';
+import { LISP_CODING_SERVICE, LISP_ASSEMBLY_SERVICE } from '../lisp-service-key.js';
 import { SemanticCompactionConfig } from '../semantic-compaction/contracts.js';
 import { MemoryReuseConfig } from '../../memory/reuse.js';
 import { MemoryRetrievalConfig } from '../../memory/retrieval-contracts.js';
@@ -61,7 +67,7 @@ import { LedgerStore } from '../../ledger/store.js';
 import { resolveProjectWorkspaceReadOnly } from '../../memory/workspaces.js';
 import { readExecutionFrame } from '../execution-frame.js';
 import { findSecret } from '../../memory/secrets.js';
-import { classifyRequestIntent, createRequestIntentContext, rebindRequestIntentDecision, requestIntentMessageRefs, requestIntentReferenceIds, requestIntentTaskType } from '../decisions/request-intent.js';
+import { classifyRequestIntent, createRequestIntentContext, rebindRequestIntentDecision, requestIntentMessageRefs, requestIntentReferenceIds, requestIntentTaskType, requestIntentIsUnresolved } from '../decisions/request-intent.js';
 import { assertMemoryOwner, createMemoryOwner } from '../memory-owner.js';
 import { executionClarification } from '../intake-clarification.js';
 export const CoreConfig = z.object({
@@ -141,9 +147,10 @@ export async function mountCore(ctx, input = {}, registrations = []) {
         const facts = await runtime.withDatabase(async (db) => {
             const project = await resolveProjectWorkspaceReadOnly(db, root, { allowDirectory: true });
             if (!project)
-                return { activeGoal: undefined, proposals: [] };
-            let runId = current?.agent === input.agent && current.task.admitted && !current.failed && !current.checkpointed
-                && current.task.workspace === project.workspace ? current.task.runId : undefined;
+                return { activeGoal: undefined, activeTask: undefined, proposals: [] };
+            const activeTask = findSessionTask(db, { sessionId: session.id, repositoryRoot: project.repositoryRoot }, { includeLatestTerminal: true });
+            let runId = activeTask?.runId ?? (current?.agent === input.agent && current.task.admitted && !current.failed && !current.checkpointed
+                && current.task.workspace === project.workspace ? current.task.runId : undefined);
             if (!runId) {
                 const owner = readExecutionOwner(db, session.id);
                 const run = owner?.run_id ? new LedgerStore(db).readRun(owner.run_id) : undefined;
@@ -152,7 +159,7 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                 }
             }
             if (!runId)
-                return { activeGoal: undefined, proposals: [] };
+                return { activeGoal: undefined, activeTask, proposals: [] };
             const workflow = readCodingWorkflow(db, runId);
             const definition = workflow && !['completed', 'cancelled', 'superseded'].includes(workflow.state) ? workflow.definition : undefined;
             const activeGoal = workflow && !['completed', 'cancelled', 'superseded'].includes(workflow.state) ? {
@@ -169,7 +176,7 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                 .map(condition => ({ id: `condition-${canonicalContentHash([runId, frame.revision, condition.field, condition.text, condition.planRevision])}`,
                 revision: condition.planRevision ?? frame.revision, digest: canonicalContentHash(condition),
                 text: `${condition.field}: ${condition.text}`, field: condition.field }));
-            return { activeGoal, proposals };
+            return { activeGoal, activeTask, proposals };
         });
         const precedingAssistant = [...(session.snapshotEvents?.() ?? [])].reverse().find(event => event.type === 'assistant/message'
             && (coreEventTurn(event) ?? Number.MAX_SAFE_INTEGER) < input.turn);
@@ -188,22 +195,64 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                         digest: canonicalContentHash(text), text }];
             }
         }
-        return createRequestIntentContext({ task, messageRefs, ...(facts.activeGoal ? { activeGoal: facts.activeGoal } : {}), proposals: proposals.slice(0, 8) });
+        return createRequestIntentContext({ task, messageRefs, ...(facts.activeGoal ? { activeGoal: facts.activeGoal } : {}), ...(facts.activeTask ? { activeTask: facts.activeTask } : {}), proposals: proposals.slice(0, 8) });
+    };
+    const persistRequestIntent = async (requestId, context, decision) => {
+        if (!context.activeTask)
+            return;
+        const identity = context.activeTask, contextDigest = canonicalContentHash(context);
+        const snapshot = await runtime.withDatabase(db => {
+            if (requestIntentIsUnresolved(decision))
+                return recordTaskUnresolved(db, identity, {
+                    operationId: `intent:${canonicalContentHash([requestId, contextDigest, decision?.unresolvedReason ?? 'request_intent_unresolved'])}`,
+                    expectedRevision: identity.revision, requestId, contextDigest,
+                    reason: decision?.unresolvedReason ?? 'request_intent_unresolved', evidence: requestIntentReferenceIds(context),
+                });
+            const current = readTaskSnapshot(db, identity);
+            return current.unresolved?.requestId === requestId && current.unresolved.contextDigest === contextDigest
+                ? clearTaskUnresolved(db, identity, { requestId, contextDigest, expectedRevision: identity.revision }) : undefined;
+        });
+        if (snapshot)
+            ctx.emit(TASK_STATE_EVENT, snapshot);
     };
     const interpretRequestIntent = async (input, task) => {
         const context = await requestIntentContextFor(input, task);
         if (!context)
             return undefined;
-        const decision = await classifyRequestIntent(decisions, dshTurnRequestId({ dshSessionId: input.agent.session.id, turn: input.turn }), context, input.signal);
+        const requestId = dshTurnRequestId({ dshSessionId: input.agent.session.id, turn: input.turn });
+        const decision = await classifyRequestIntent(decisions, requestId, context, input.signal);
+        await persistRequestIntent(requestId, context, decision);
         return decision ? { context, decision } : undefined;
     };
     const demand = new OnDemandIntake({
         answerContext: new DshAnswerContext(runtime, { root, projectOnly: true, memoryRetrieval: config.memoryRetrieval,
             instructions: (input, task, taskType) => answerSkillContext(input, task, taskType, { skills, prompts, decisions, cwd: root }),
         }),
+        nativeOwnership: async (input) => {
+            const agent = input.agent;
+            bind(agent);
+            const session = agent.session;
+            if (!session?.header)
+                throw new Error('Native ownership requires the current session header');
+            const header = session.header;
+            if (header.parentSession || header.isSeeded)
+                return 'owned';
+            const jobs = get('jobs');
+            if (jobs && jobs.list(session.id).some(job => !['completed', 'killed', 'failed'].includes(job.status)))
+                return 'owned';
+            const current = active.get(session.id);
+            const ownership = await runtime.withDatabase(db => nativeExecutionOwnership(db, session.id, current?.task.runId));
+            input.signal.throwIfAborted();
+            // Retire only the exact completed in-memory projection proven above.
+            // Durable history remains intact; no memory lookup or save is involved.
+            if (ownership === 'unowned' && current && active.get(session.id) === current)
+                active.delete(session.id);
+            return ownership;
+        },
         nativeChild: agent => agents?.get(agent.id) === agent && sessions?.get(agent.session?.id) === agent.session && isNativeSubagent(agent),
         validate: async (input) => {
             bind(input.agent);
+            await discardStaleActive(input.agent);
             await runtime.withDatabase(db => {
                 for (const id of legacyModuleRequirements(db, input.agent.session.id)) {
                     if (!modules.ids().includes(id))
@@ -244,7 +293,7 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                 return;
             const retainsGoal = (requestIntent?.relation === 'same_scope_continuation' || requestIntent?.relation === 'scope_change')
                 && requestIntent.action !== 'answer'
-                && requestIntent.evidence.runId === current.task.runId;
+                && (requestIntent.evidence.runId === current.task.runId || requestIntent.evidence.taskId === current.task.runId);
             if (retainsGoal)
                 return;
             await finishSession(sessionId);
@@ -253,24 +302,21 @@ export async function mountCore(ctx, input = {}, registrations = []) {
         },
         existing: async (input, requestIntent) => {
             const sessionId = input.agent.session.id;
-            const sameScope = requestIntent?.relation === 'same_scope_continuation'
-                && requestIntent.action !== 'answer' && requestIntent.action !== 'unknown';
-            if (!sameScope)
+            if (requestIntent?.relation !== 'same_scope_continuation' || ['answer', 'unknown'].includes(requestIntent.action))
                 return false;
             return runtime.withDatabase(async (db) => {
                 const project = await resolveProjectWorkspaceReadOnly(db, root, { allowDirectory: true });
                 if (!project)
                     return false;
-                const owner = readExecutionOwner(db, sessionId);
-                if (!owner?.run_id || owner.mode !== 'normal' || owner.workspace !== project.workspace)
-                    return false;
-                const run = new LedgerStore(db).readRun(owner.run_id);
-                if (!run || run.status !== 'active' || run.dshSessionId !== sessionId)
+                const task = findSessionTask(db, { sessionId, repositoryRoot: project.repositoryRoot });
+                if (!task || !taskCanExecute(task) || requestIntent.evidence.taskId !== task.taskId
+                    || requestIntent.evidence.taskRevision !== task.revision || requestIntent.evidence.taskGeneration !== task.generation)
                     return false;
-                if (requestIntent?.evidence.runId !== owner.run_id)
+                const owner = readExecutionOwner(db, sessionId);
+                if (owner && (owner.run_id !== task.runId || owner.mode !== 'normal' || owner.workspace !== project.workspace))
                     return false;
-                const workflow = readCodingWorkflow(db, owner.run_id);
-                return !!workflow && !['completed', 'cancelled', 'superseded'].includes(workflow.state);
+                captureTaskLease(db, task);
+                return true;
             });
         },
         classify: (input, task) => classifyTaskForIntake(decisions, dshTurnRequestId({ dshSessionId: input.agent.session.id, turn: input.turn }), task, undefined, input.signal),
@@ -284,14 +330,32 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                 return false;
             const current = active.get(agent.session?.id ?? '');
             return !!current && current.agent === agent && current.agent.session === agent.session && (turn === undefined || current.turn === turn)
-                && current.task.admitted && !current.failed && !current.checkpointed && !stopped;
+                && current.task.admitted && !current.failed && !current.checkpointed && !current.invalidated && !stopped;
         },
     }, { onlyWhenDeferred: config.intakeMode === 'eager' });
+    const taskWorkflow = new DshTaskWorkflow({ runtime, demand, agents, sessions, skills, tools,
+        lisp: () => get(LISP_ASSEMBLY_SERVICE),
+        checkpointSource: async (agent) => { bind(agent); await sessions.flush(agent.session); bind(agent); },
+        onCompleted: task => lifecycleMemory?.completed(task.taskId, 'completed', task.sessionId, task),
+        emit: task => { ctx.emit(TASK_STATE_EVENT, task); } });
     const conversationSessions = new WeakSet();
     function bind(agent) {
         if (!agent?.session || agents?.get(agent.id) !== agent || sessions?.get(agent.session.id) !== agent.session || realpathSync(agent.session.header.cwd) !== root)
             throw new Error('Native task identity mismatch');
     }
+    async function discardStaleActive(agent) {
+        const current = active.get(agent.session.id);
+        if (!current || current.agent !== agent || !current.task.authority)
+            return;
+        try {
+            await runtime.withDatabase(db => authorizeTaskLease(db, current.task.authority));
+        }
+        catch {
+            current.invalidated = true;
+            if (active.get(agent.session.id) === current)
+                active.delete(agent.session.id);
+        }
+    }
     function track(promise) {
         pending.add(promise);
         void promise.then(() => pending.delete(promise), () => pending.delete(promise));
@@ -304,6 +368,9 @@ export async function mountCore(ctx, input = {}, registrations = []) {
         if (current.finishing)
             return current.finishing;
         bind(current.agent);
+        await discardStaleActive(current.agent);
+        if (active.get(sessionId) !== current)
+            return;
         const boundary = [...current.agent.session.snapshotEvents()].reverse().find(event => event.type === 'turn/end' && event.data?.turn === current.turn);
         const reason = boundary?.data?.reason?.kind;
         if (!['completed', 'error', 'aborted', 'max-tokens', 'blocked'].includes(reason))
@@ -371,6 +438,7 @@ export async function mountCore(ctx, input = {}, registrations = []) {
     }
     async function prepareCoreTask(payload, signal, advisoryType, suppliedIntent, suppliedContext) {
         const key = `${payload.agent.session.id}\u0000${payload.turn}`;
+        await discardStaleActive(payload.agent);
         const existing = active.get(payload.agent.session.id);
         const newText = humanTask(payload.messages);
         const steering = existing?.turn === payload.turn && newText.length > 0 && newText !== existing.taskText;
@@ -401,9 +469,11 @@ export async function mountCore(ctx, input = {}, registrations = []) {
         else if (!exactPreparedRequest && requestIntentContext) {
             requestIntent = await classifyRequestIntent(decisions, requestId, requestIntentContext, signal);
         }
+        if (requestIntentContext)
+            await persistRequestIntent(requestId, requestIntentContext, requestIntent);
         const intentUnresolved = requestIntent?.relation === 'unknown' || requestIntent?.action === 'unknown';
         const legacyTaskTypeAllowed = advisoryType !== undefined && advisoryType !== 'chat'
-            && !requestIntentContext?.activeGoal && (requestIntentContext?.proposals.length ?? 0) === 0;
+            && !requestIntentContext?.activeGoal && !requestIntentContext?.activeTask && (requestIntentContext?.proposals.length ?? 0) === 0;
         if ((intentUnresolved && !legacyTaskTypeAllowed) || requestIntent?.action === 'answer') {
             throw new KiokukoError('CONFLICT', 'request_intent_unresolved');
         }
@@ -412,7 +482,7 @@ export async function mountCore(ctx, input = {}, registrations = []) {
             throw new KiokukoError('VALIDATION_ERROR', clarification);
         if (intentUnresolved && legacyTaskTypeAllowed)
             requestIntent = undefined;
-        if (requestIntentContext?.activeGoal && requestIntent === undefined) {
+        if ((requestIntentContext?.activeGoal || requestIntentContext?.activeTask) && requestIntent === undefined) {
             throw new KiokukoError('CONFLICT', 'request_intent_required_for_active_goal');
         }
         const resumesScope = requestIntent && (requestIntent.relation === 'same_scope_continuation' || requestIntent.relation === 'scope_change');
@@ -485,7 +555,22 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                 throw new Error('Native capability inventory is incomplete');
             const schemas = stableLispCapabilities(await tools.schemas(payload.agent), payload.agent);
             request = { ...request, capabilities: [...snapshot.skills.filter((skill) => skill.invocation?.modelInvocable !== false).map((skill) => ({ kind: 'skill', name: skill.name, ...(skill.description ? { description: skill.description } : {}) })),
-                    ...schemas.map((tool) => ({ kind: 'tool', name: tool.name, ...(tool.description ? { description: tool.description } : {}) }))] };
+                    ...schemas.map((tool) => ({ kind: 'tool', name: tool.name, ...(tool.description ? { description: tool.description } : {}) }))],
+                validateCapabilities: async () => {
+                    signal.throwIfAborted();
+                    bind(payload.agent);
+                    const latest = await skills.snapshot({ scope: payload.agent, cwd: root, signal });
+                    if (!latest.complete)
+                        throw new Error('Native capability inventory is incomplete');
+                    const latestSchemas = stableLispCapabilities(await tools.schemas(payload.agent), payload.agent);
+                    const capabilities = [...latest.skills.filter((skill) => skill.invocation?.modelInvocable !== false)
+                            .map((skill) => ({ kind: 'skill', name: skill.name, ...(skill.description ? { description: skill.description } : {}) })),
+                        ...latestSchemas.map((tool) => ({ kind: 'tool', name: tool.name, ...(tool.description ? { description: tool.description } : {}) }))];
+                    signal.throwIfAborted();
+                    bind(payload.agent);
+                    if (capabilityCatalogDigest(capabilities) !== capabilityCatalogDigest(request.capabilities))
+                        throw new Error('Native capabilities changed during intake');
+                } };
             const resuming = !!resumesScope;
             let task = resuming ? await tasks.resume(request) : await tasks.prepare(request);
             if (resuming && requestIntent?.relation === 'same_scope_continuation' && task.memoryOwner?.kind === 'execution') {
@@ -521,6 +606,11 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                 attachmentTypes: attachmentTypesFromMessages(payload.messages), failed: false, checkpointed: false, contextDelivered: false, memoryRebuildAttempts: 0 });
             if (!task.admitted)
                 return task;
+            const authority = task.authority;
+            if (!authority)
+                throw new Error('Admitted core task has no repository authority');
+            const taskSnapshot = await runtime.withDatabase(db => authorizeTaskLease(db, authority));
+            ctx.emit(TASK_STATE_EVENT, taskSnapshot);
             if (task.profile.taskType === 'chat')
                 conversationSessions.add(payload.agent.session);
             else
@@ -530,7 +620,7 @@ export async function mountCore(ctx, input = {}, registrations = []) {
             answerReview.bind({ runId: task.runId, workspace: task.workspace, requestId: task.requestId, task: text, catalogDigest: capabilityCatalogDigest(task.capabilities),
                 turn: payload.turn, agent: reviewAgent,
                 current: () => active.get(task.sessionId) === owner && agents?.get(payload.agent.id) === payload.agent && sessions?.get(task.sessionId) === payload.agent.session,
-                eligible: () => !stopped && owner.task.admitted && !owner.failed && !owner.checkpointed && !reviewAgent.session.header?.parentSession && reviewAgent.session.header?.origin !== 'subagent' && !reviewAgent.session.header?.delegationDepth,
+                eligible: () => !stopped && owner.task.admitted && !owner.failed && !owner.checkpointed && !isNativeSubagent(reviewAgent),
                 settled: async () => { if (active.get(task.sessionId) === owner)
                     await finishSession(task.sessionId); },
             });
@@ -613,7 +703,14 @@ export async function mountCore(ctx, input = {}, registrations = []) {
         if (!skills?.registerProvider || !skills.snapshot || !tools?.schemas || !tools.guard || !tools.register || !sessions?.get || !sessions.flush || !agents?.get || !systemPrompt?.section)
             throw new Error('Core requires native Skill, prompt, tool, session and agent services');
         await runtime.start();
+        disposers.push(ctx.on(TASK_STATE_EVENT, (snapshot) => {
+            const current = active.get(snapshot.sessionId);
+            if (current?.task.authority && current.task.runId === snapshot.taskId
+                && (current.task.authority.revision !== snapshot.revision || current.task.authority.generation !== snapshot.generation))
+                current.invalidated = true;
+        }));
         lifecycleMemory = new DshLifecycleMemory(ctx, runtime, root);
+        lifecycleMemory.connectIntake(demand);
         await decisions.initialize();
         const provider = configuredSkillProvider(modules.resources(), prompts);
         disposers.push(() => provider.dispose());
@@ -631,13 +728,33 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                 throw new Error('Native ingress already has an owner'); claimed = true; },
             beforeTask(handler) { beforeTask.add(handler); return () => { beforeTask.delete(handler); }; } });
         if (!claimed) {
-            const resolveOwned = (execution) => {
+            // The native-ingress owner also owns its task-control surface and intake proofs.
+            disposers.push(mountTaskWorkflowSurface(ctx, taskWorkflow, demand));
+            const resolveParentOwned = (execution) => {
                 if (!execution.agent)
                     return undefined;
                 bind(execution.agent);
                 const current = active.get(execution.agent.session.id);
-                return current && current.agent === execution.agent && current.task.admitted && !current.failed && !current.checkpointed
-                    ? { ...current.task, repositoryRoot: root, generation: canonicalContentHash({ run: current.task.runId, task: current.taskText }), agent: execution.agent } : undefined;
+                return current && current.agent === execution.agent && current.task.admitted && current.task.authority && !current.failed && !current.checkpointed
+                    ? { ...current.task, repositoryRoot: current.task.authority.repositoryRoot, generation: canonicalContentHash({ run: current.task.runId, task: current.taskText }), agent: execution.agent } : undefined;
+            };
+            const nativeTaskAuthority = new NativeTaskAuthority({ runtime, repositoryRoot: root, backend: get('subagents'), agents, sessions, resolveParent: resolveParentOwned });
+            disposers.push(() => nativeTaskAuthority.dispose());
+            const resolveOwned = (execution) => nativeTaskAuthority.resolve(execution) ?? resolveParentOwned(execution);
+            const resolveOwnedRead = async (execution) => {
+                if (!execution.agent)
+                    return undefined;
+                bind(execution.agent);
+                if (isNativeSubagent(execution.agent))
+                    return nativeTaskAuthority.read(execution);
+                const current = resolveParentOwned(execution);
+                if (execution.name === 'kioku_read' && current)
+                    return current;
+                return await runtime.withDatabase(async (db) => {
+                    const project = await resolveProjectWorkspaceReadOnly(db, root, { allowDirectory: true });
+                    return project ? readOwnedIdentity(db, execution.agent, project.repositoryRoot, execution.name === 'kioku_result' ? execution.arguments?.operationId : undefined) : undefined;
+                })
+                    ?? resolveParentOwned(execution);
             };
             disposers.push(mountTaskCompletion({ tools, on: ctx.on.bind(ctx) }, { runtime, resolve: resolveOwned, approve: async () => true }));
             disposers.push(mountCodingWorkflow({ tools, on: ctx.on.bind(ctx) }, { runtime,
@@ -695,7 +812,9 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                     return memory;
                 },
             }));
-            disposers.push(mountOwnedExecution({ tools, on: ctx.on.bind(ctx) }, { runtime, resolve: resolveOwned,
+            disposers.push(mountOwnedExecution({ tools, on: ctx.on.bind(ctx) }, { runtime, resolve: resolveOwned, resolveRead: resolveOwnedRead,
+                unownedNative: execution => demand?.unownedNative(execution) === true,
+                isTaskControl: execution => get(TASK_WORKFLOW_SERVICE)?.isControl(execution) === true,
                 planActive: agent => get('planMode')?.get(agent)?.active === true,
                 async confirm(identity, detail, signal) {
                     if (!questions)
@@ -748,7 +867,7 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                     if (mode === 'off')
                         return undefined;
                     if (!owner || owner.agent !== agent || !owner.task.admitted || owner.failed || owner.checkpointed
-                        || agent.session.header.parentSession || agent.session.header.origin === 'subagent' || agent.session.header.delegationDepth)
+                        || isNativeSubagent(agent))
                         return { kind: 'native' };
                     if (get(LISP_CODING_SERVICE)?.enabled(agent))
                         return { kind: 'native' };
@@ -958,7 +1077,7 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                 return undefined;
             }));
             const argumentsSchema = z.object({ outcome: z.enum(['completed', 'failed', 'cancelled']), memories: z.array(z.unknown()).max(100).optional(), evidence: z.unknown().optional() }).strict();
-            disposers.push(tools.register({ name: 'memory_checkpoint', description: 'Save durable project memory for this admitted request.', modelFacing: true, output: { schema: {}, render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }] }, parameters: JSON.parse(JSON.stringify(z.toJSONSchema(argumentsSchema))),
+            disposers.push(tools.register({ name: 'memory_checkpoint', description: 'Memory saving requires post-task human review. This legacy tool does not save memories.', modelFacing: true, output: { schema: {}, render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }] }, parameters: JSON.parse(JSON.stringify(z.toJSONSchema(argumentsSchema))),
                 execute: (args, execution) => track((async () => {
                     if (stopped)
                         throw new Error('Core is stopped');
@@ -967,7 +1086,6 @@ export async function mountCore(ctx, input = {}, registrations = []) {
                     if (!current || current.agent !== execution.agent || current.checkpointed || execution.name !== 'memory_checkpoint')
                         throw new Error('No open bound task for memory checkpoint');
                     const result = await tasks.checkpoint(current.task, argumentsSchema.parse(args), execution.signal);
-                    current.checkpointed = true;
                     return result;
                 })()) }));
         }