maka-agent 0.2.0-dev.5.20260830 → 0.2.0-dev.8.20260830

package/node_modules/@maka/core/dist/agent-run.js

@@ -161,8 +161,6 @@ export const AGENT_RUN_EVENT_TYPES = [
     'run_created',
     'run_started',
     'turn_started',
-    'sandbox_context_resolved',
-    'sandbox_context_failed',
     'plan_context_resolved',
     'plan_submitted',
     'plan_execution_started',

package/node_modules/@maka/core/dist/foreign-session.js

@@ -518,7 +518,7 @@ export function stripEnvelopeTags(text) {
 }
 /**
  * Render a digest as an explicitly-untrusted data block for the handoff
- * prompt. The envelope wording mirrors the memory/turn-tail discipline:
+ * prompt. The envelope wording mirrors the untrusted-context discipline:
  * contents are reference data, never instructions. `safe()` is the
  * authoritative gate every foreign-authored scalar passes through here —
  * regardless of how the digest was built — sanitizing (NFC, control/bidi/

package/node_modules/@maka/core/dist/task-ledger.js

@@ -17,31 +17,24 @@
  * under the License.
  */
 // Session-scoped task ledger primitive for the main agent. The model manages a
-// flat task list via task_create/task_update; each turn tail re-injects the
-// current list. The durable contract is intentionally narrow: task status,
+// flat task list via task_create/task_update and reads it through task_list/task_get.
+// The durable contract is intentionally narrow: task status,
 // compact evidence/reason fields, append-only task events, and conservative
 // resume trust diagnostics. Priority, dependencies, and assignee fields remain
 // out of scope.
 import { redactSecrets } from './redaction.js';
 export const TASK_SUBJECT_MAX_CHARS = 200;
 export const TASK_EVIDENCE_MAX_CHARS = 1000;
-/**
- * Hard cap on total tasks per session ledger (any status). The full ledger is
- * re-injected into every turn tail, so an unbounded ledger burns context on
- * every turn; this is a runaway guard on the total count, not a workflow quota
- * — completing or cancelling tasks does not free capacity.
- */
+/** Hard cap on total tasks per session ledger (any status). */
 export const TASK_LEDGER_MAX_TASKS = 200;
 export const TASK_ARCHIVE_AFTER_MS = 7 * 24 * 60 * 60 * 1000;
 /**
  * Max length of a task id accepted on both the write and read paths. The write
  * path generates randomUUID (36 chars); the bound leaves headroom for a future
- * id format while keeping the turn-tail `id=` fielded render bounded.
+ * id format while keeping model-visible fielded renders bounded.
  */
 export const TASK_ID_MAX_CHARS = 64;
 export const TASK_KEY_MAX_CHARS = 64;
-export const TASK_LEDGER_PROMPT_MAX_CHARS = 8_000;
-export const TASK_LEDGER_PROMPT_RECENT_TERMINAL = 3;
 export const TASK_STATUSES = [
     'pending',
     'in_progress',
@@ -74,7 +67,7 @@ export function isResumeTrust(value) {
  * ever rendered it: no angle brackets/slashes/quotes/parens/equals (a past
  * whole-string tag strip would have eaten them; even the fielded renderer
  * emits the id bare), no whitespace (would break the list-line structure), no
- * huge length (would bloat every turn tail), and redaction-stable (a renderer
+ * huge length (would bloat model-visible results), and redaction-stable (a renderer
  * that runs redactSecrets must not turn the id into [redacted] while the store
  * keeps the real id -- a later task_update would miss). The whitelist
  * (alphanumeric plus . _ : -, 1-64 chars) plus redactSecrets(id) === id enforces
@@ -95,19 +88,6 @@ export function isTaskKey(value) {
         value.length <= TASK_KEY_MAX_CHARS &&
         /^T[1-9]\d*(?:\.[1-9]\d*)*$/.test(value));
 }
-export function compareTaskKeys(left, right) {
-    const a = left.slice(1).split('.').map(Number);
-    const b = right.slice(1).split('.').map(Number);
-    for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
-        if (a[index] === undefined)
-            return -1;
-        if (b[index] === undefined)
-            return 1;
-        if (a[index] !== b[index])
-            return a[index] - b[index];
-    }
-    return 0;
-}
 export function findTaskByRef(tasks, ref) {
     return tasks.find((task) => task.id === ref || task.key === ref);
 }
@@ -398,7 +378,7 @@ function validateTaskLedgerEventType(event, current) {
 }
 /**
  * Safe-render the task ledger for any face that persists into history or is
- * re-injected into a prompt (tool results, turn-tail fragment). Two invariants:
+ * included in a model-visible tool result. Two invariants:
  *   - the canonical id is rendered verbatim, and the subject is a safe
  *     (redacted, tag-stripped) rendered payload of what the store holds; and
  *   - the model can unambiguously recover each task's id from what it sees, so
@@ -456,114 +436,6 @@ export function sanitizeTaskLedgerTask(task) {
             : {}),
     };
 }
-export function renderTaskLedgerPromptText(tasks, maxChars = TASK_LEDGER_PROMPT_MAX_CHARS) {
-    const byId = new Map(tasks.map((task) => [task.id, task]));
-    const selected = new Set();
-    const addWithAncestors = (task) => {
-        const chain = [];
-        let current = task;
-        const seen = new Set();
-        while (current && !seen.has(current.id)) {
-            seen.add(current.id);
-            chain.unshift(current);
-            current = current.parentId ? byId.get(current.parentId) : undefined;
-        }
-        for (const item of chain)
-            selected.add(item.id);
-    };
-    const active = tasks
-        .filter((task) => !isTerminalTaskStatus(task.status))
-        .sort(compareTaskPromptPriority);
-    for (const task of active)
-        addWithAncestors(task);
-    const recentTerminal = tasks
-        .filter((task) => isTerminalTaskStatus(task.status) && task.status !== 'cancelled')
-        .sort((a, b) => (b.endedAt ?? b.updatedAt) - (a.endedAt ?? a.updatedAt) || compareTaskKeys(a.key, b.key))
-        .slice(0, TASK_LEDGER_PROMPT_RECENT_TERMINAL);
-    for (const task of recentTerminal)
-        addWithAncestors(task);
-    const chosen = tasks.filter((task) => selected.has(task.id));
-    const ordered = orderTaskTree(chosen);
-    const lines = [];
-    const included = [];
-    const includedIds = new Set();
-    for (const task of ordered) {
-        if (task.parentId && !includedIds.has(task.parentId))
-            continue;
-        const depth = task.key.split('.').length - 1;
-        const fields = [
-            `key=${task.key}`,
-            `status=${task.status}`,
-            `subject=${JSON.stringify(safeTaskLedgerField(task.subject))}`,
-        ];
-        if (task.blockedReason)
-            fields.push(`blockedReason=${JSON.stringify(safeTaskLedgerField(task.blockedReason))}`);
-        if (task.failureReason)
-            fields.push(`failureReason=${JSON.stringify(safeTaskLedgerField(task.failureReason))}`);
-        if (task.completionEvidence)
-            fields.push(`completionEvidence=${JSON.stringify(safeTaskLedgerField(task.completionEvidence))}`);
-        if (task.owner)
-            fields.push(`owner=${JSON.stringify(task.owner)}`);
-        const line = `${'  '.repeat(depth)}${fields.join(' ')}`;
-        const nextLength = lines.length === 0 ? line.length : lines.join('\n').length + 1 + line.length;
-        if (nextLength > maxChars)
-            continue;
-        lines.push(line);
-        included.push(task);
-        includedIds.add(task.id);
-    }
-    return {
-        text: lines.join('\n'),
-        included,
-        omittedCount: tasks.length - included.length,
-    };
-}
-function compareTaskPromptPriority(left, right) {
-    return (taskStatusRank(left.status) - taskStatusRank(right.status) ||
-        compareTaskKeys(left.key, right.key));
-}
-function orderTaskTree(tasks) {
-    const byParent = new Map();
-    for (const task of tasks) {
-        const bucket = byParent.get(task.parentId) ?? [];
-        bucket.push(task);
-        byParent.set(task.parentId, bucket);
-    }
-    const branchRanks = new Map();
-    const branchRank = (task) => {
-        const cached = branchRanks.get(task.id);
-        if (cached !== undefined)
-            return cached;
-        const rank = Math.min(taskStatusRank(task.status), ...(byParent.get(task.id) ?? []).map(branchRank));
-        branchRanks.set(task.id, rank);
-        return rank;
-    };
-    const out = [];
-    const visit = (parentId) => {
-        for (const task of (byParent.get(parentId) ?? []).sort((left, right) => branchRank(left) - branchRank(right) || compareTaskKeys(left.key, right.key))) {
-            out.push(task);
-            visit(task.id);
-        }
-    };
-    visit(undefined);
-    return out;
-}
-function taskStatusRank(status) {
-    switch (status) {
-        case 'in_progress':
-            return 0;
-        case 'pending':
-            return 1;
-        case 'blocked':
-            return 2;
-        case 'completed':
-            return 3;
-        case 'failed':
-            return 4;
-        case 'cancelled':
-            return 5;
-    }
-}
 export function renderTaskLedgerDebugText(tasks) {
     if (tasks.length === 0)
         return '';

package/node_modules/@maka/core/dist/usage-record-schema.js

@@ -154,6 +154,7 @@ const PROMPT_SEGMENT_KINDS = new Set([
     'tool_schema',
     'prior_history',
     'current_user',
+    // Read compatibility for historical usage rows; current writers do not emit it.
     'turn_tail',
 ]);
 const PREFIX_CHANGE_REASONS = new Set([

package/node_modules/@maka/runtime/dist/ai-sdk-backend.js

@@ -42,10 +42,8 @@ import { contextDiagnosticsCompactionOf, } from './context-diagnostics.js';
 import { AiSdkCompaction, hasActiveToolResultPruneDiagnosticPatch, hasBlockingReplayDiagnostics, } from './ai-sdk-compaction.js';
 import { openAiChatReasoningFieldFromProviderOptions } from './openai-chat-reasoning-transport.js';
 import { RunTrace } from './run-trace.js';
-import { toSandboxRunTraceProjection, } from './sandbox/diagnostics.js';
 import { SandboxCommandError } from './sandbox/errors.js';
 import { REQUEST_SANDBOX_BOUNDARY_TOOL_NAME, SANDBOX_BOUNDARY_DENIED_FOR_TURN, SANDBOX_BOUNDARY_FINALIZATION_PROMPT, } from './sandbox-boundary-tool.js';
-import { renderSandboxTurnTailPrompt } from './system-prompt/sandbox-context-prompt.js';
 import { computeCost } from './telemetry/cost.js';
 import { getBuiltinPricing } from './telemetry/builtin-pricing.js';
 import { buildRuntimeEventModelReplayPlan, buildSteeringEnvelope, collectToolActivityTurnIds, formatTextWithInlineRefs, steeringMessagesMissingFromBase, steeringModelMessage, steeringProviderOptions, } from './model-history.js';
@@ -621,7 +619,6 @@ export class AiSdkBackend {
             createProviderRequestTracker: (trackerInput) => this.createProviderRequestTracker(trackerInput),
             materializeRuntimeReplayPlan: (plan, imageBudget, checkpoint) => this.materializeRuntimeReplayPlan(plan, imageBudget, undefined, checkpoint),
             canReplayProviderNative: (plan) => this.canReplayProviderNative(plan),
-            appendTurnTailPrompt: (content, turnTailPrompt) => this.appendTurnTailPrompt(content, turnTailPrompt),
         });
         if (input.tools.some((tool) => tool.name === MEMORY_REMEMBER_TOOL_NAME || tool.name === MEMORY_EXTRACT_TOOL_NAME)) {
             throw new Error('Long-term Memory trigger tool names are reserved by Runtime');
@@ -1032,48 +1029,6 @@ export class AiSdkBackend {
                 });
             }
         }
-        let sandboxDiagnosticsSnapshot;
-        let sandboxPrompt;
-        let sandboxContextStage = 'resolve';
-        try {
-            sandboxDiagnosticsSnapshot = this.input.sandboxDiagnostics
-                ? await raceWithTurnAbort(this.resolveTurnSandboxDiagnostics(), turnAbortController.signal)
-                : undefined;
-            sandboxContextStage = 'render';
-            sandboxPrompt = sandboxDiagnosticsSnapshot
-                ? renderSandboxTurnTailPrompt(sandboxDiagnosticsSnapshot)
-                : undefined;
-        }
-        catch (err) {
-            if (scope.aborted || turnAbortController.signal.aborted) {
-                queue.push({
-                    type: 'abort',
-                    id: this.newId(),
-                    turnId,
-                    ts: this.now(),
-                    reason: 'user_stop',
-                });
-                queue.push({
-                    type: 'complete',
-                    id: this.newId(),
-                    turnId,
-                    ts: this.now(),
-                    stopReason: 'user_stop',
-                });
-                queue.close();
-                yield* this.drain(queue);
-                return;
-            }
-            trace.sandboxContextFailed(sandboxContextStage, err);
-            // This context is model guidance, not execution authority. Never fall
-            // back to a stale snapshot; continue without the prompt while the live
-            // ExecutionBoundary remains authoritative for every tool invocation.
-            sandboxDiagnosticsSnapshot = undefined;
-            sandboxPrompt = undefined;
-        }
-        if (sandboxDiagnosticsSnapshot) {
-            trace.sandboxContextResolved(toSandboxRunTraceProjection(sandboxDiagnosticsSnapshot));
-        }
         const providerRequestTracker = this.createProviderRequestTracker({
             turnId,
             callKind: 'main',
@@ -1167,11 +1122,6 @@ export class AiSdkBackend {
                 await this.resolveSystemPrompt(scope),
                 scope.orchestration?.mode === 'swarm' ? renderSwarmModePrompt() : undefined,
                 scope.orchestration?.mode === 'graph' ? renderGraphModePrompt() : undefined,
-                // A safe continuation deliberately has no new user message. Keep its
-                // replay byte-for-byte intact and carry only the current authority fact
-                // in the effective system envelope; ordinary volatile turn-tail facts
-                // remain excluded from continuation.
-                input.continuation ? sandboxPrompt : undefined,
             ]);
         }
         catch (err) {
@@ -1305,13 +1255,6 @@ export class AiSdkBackend {
                     next.start();
                 };
                 const activeTools = plan.activeTools;
-                const turnTailPrompt = input.continuation
-                    ? undefined
-                    : joinPromptFragments([
-                        await this.resolveTurnTailPrompt(turnId),
-                        await this.resolveShellRunContextSummary(),
-                        sandboxPrompt,
-                    ]);
                 const currentUserContent = input.continuation
                     ? undefined
                     : await this.buildCurrentUserContent(scope.imageBudget, input.text, input.attachments, input.quotes, input.headAnchorRuntimeEvent?.id);
@@ -1321,7 +1264,7 @@ export class AiSdkBackend {
                         ...priorReplay.messages,
                         {
                             role: 'user',
-                            content: this.appendTurnTailPrompt(currentUserContent, turnTailPrompt),
+                            content: currentUserContent,
                         },
                     ];
                 const settledModelOutputs = new Map();
@@ -1364,22 +1307,7 @@ export class AiSdkBackend {
                         (replayPlan.hasProviderNativeSemantics && !this.canReplayProviderNative(replayPlan))) {
                         throw new Error('durable current-run projection is not replayable');
                     }
-                    const anchorEventId = input.headAnchorRuntimeEvent?.id;
-                    let decoratedCurrentUser = false;
-                    const replayItems = replayPlan.items.map((item) => {
-                        if (item.kind !== 'text' || item.role !== 'user') {
-                            return item;
-                        }
-                        if (anchorEventId !== undefined ? item.eventId !== anchorEventId : decoratedCurrentUser) {
-                            return item;
-                        }
-                        decoratedCurrentUser = true;
-                        return {
-                            ...item,
-                            content: this.appendTurnTailPrompt(item.content, turnTailPrompt),
-                        };
-                    });
-                    const currentTurnMessages = await this.materializeRuntimeReplayPlan({ ...replayPlan, items: replayItems }, scope.imageBudget, settledModelOutputs, projectionCheckpoint);
+                    const currentTurnMessages = await this.materializeRuntimeReplayPlan(replayPlan, scope.imageBudget, settledModelOutputs, projectionCheckpoint);
                     return projectionCheckpoint
                         ? currentTurnMessages
                         : [...priorReplay.messages, ...currentTurnMessages];
@@ -1408,7 +1336,6 @@ export class AiSdkBackend {
                                     ...(input.attachments !== undefined ? { attachments: input.attachments } : {}),
                                     ...(input.quotes !== undefined ? { quotes: input.quotes } : {}),
                                 }),
-                            turnTailPrompt,
                         }),
                         requestShape: computeRequestShapeDiagnostic({
                             connection: this.input.connection,
@@ -1460,7 +1387,7 @@ export class AiSdkBackend {
                     midTurnCompactDiagnosticPatch = mergeContextBudgetDiagnosticPatches(midTurnCompactDiagnosticPatch, patch);
                 };
                 const midTurnSystemPromptChars = systemPrompt?.length ?? 0;
-                const midTurnCapacityHook = this.compaction.buildMidTurnCapacityCompactProjection(turnId, midTurnState, queue, providerTools, () => currentRepairToolNames(), turnTailPrompt, midTurnSystemPromptChars, onMidTurnDiagnosticPatch, scope, this.automaticMemoryCompactionSupported()
+                const midTurnCapacityHook = this.compaction.buildMidTurnCapacityCompactProjection(turnId, midTurnState, queue, providerTools, () => currentRepairToolNames(), midTurnSystemPromptChars, onMidTurnDiagnosticPatch, scope, this.automaticMemoryCompactionSupported()
                     ? () => this.automaticMemoryCompactionDecision()
                     : undefined, this.automaticMemoryCompactionSupported()
                     ? (dispatch) => this.dispatchAutomaticMemoryCompaction(scope, dispatch)
@@ -1855,7 +1782,6 @@ export class AiSdkBackend {
                                     providerTools,
                                     activeTools: activeToolsForRequest,
                                     systemPromptChars: midTurnSystemPromptChars,
-                                    turnTailPrompt,
                                     queue,
                                     onDiagnosticPatch: onMidTurnDiagnosticPatch,
                                     origin: scope,
@@ -3432,17 +3358,6 @@ export class AiSdkBackend {
         }
         return out;
     }
-    /** Append provider-visible volatile turn facts after the durable user content. */
-    appendTurnTailPrompt(content, turnTailPrompt) {
-        if (!turnTailPrompt)
-            return content;
-        if (typeof content === 'string')
-            return `${content}\n\n${turnTailPrompt}`;
-        return [
-            ...content,
-            { type: 'text', text: turnTailPrompt },
-        ];
-    }
     /** A decision key deduplicates re-materialization; no key charges each occurrence. */
     chargeImageBudget(budget, bytes, decisionKey) {
         if (decisionKey !== undefined) {
@@ -3558,39 +3473,12 @@ export class AiSdkBackend {
             return await this.input.systemPrompt({
                 sessionId: this.sessionId,
                 turnId,
-                ...(scope.runId ? { runId: scope.runId } : {}),
                 cwd: this.input.header.cwd,
-                workspaceRoot: this.input.header.workspaceRoot,
                 emitSkillCatalogTrace: (message, data) => scope.runTrace?.emit('skill', 'skill_catalog_built', message, data),
             });
         }
         return this.input.systemPrompt;
     }
-    async resolveTurnSandboxDiagnostics() {
-        const provider = this.input.sandboxDiagnostics;
-        if (!provider)
-            return undefined;
-        const boundary = await this.input.readExecutionBoundary();
-        if (boundary.kind === 'external')
-            return undefined;
-        return await provider.resolve(boundary.kind === 'managed'
-            ? { cwd: this.input.header.cwd, permissionProfile: boundary.profile }
-            : { cwd: this.input.header.cwd, mode: 'bypass' });
-    }
-    async resolveTurnTailPrompt(turnId) {
-        if (typeof this.input.turnTailPrompt === 'function') {
-            return await this.input.turnTailPrompt({
-                sessionId: this.sessionId,
-                turnId,
-                cwd: this.input.header.cwd,
-                workspaceRoot: this.input.header.workspaceRoot,
-            });
-        }
-        return this.input.turnTailPrompt;
-    }
-    async resolveShellRunContextSummary() {
-        return await this.input.shellRunContextSummary?.();
-    }
     async *drain(queue) {
         try {
             for await (const ev of queue) {

package/node_modules/@maka/runtime/dist/ai-sdk-compaction.js

@@ -37,7 +37,6 @@ export class AiSdkCompaction {
     createProviderRequestTracker;
     materializeRuntimeReplayPlan;
     canReplayProviderNative;
-    appendTurnTailPrompt;
     historyCompactAbortController = null;
     /**
      * Session-scoped circuit for exact malformed compaction inputs. A retry or
@@ -53,7 +52,6 @@ export class AiSdkCompaction {
         this.createProviderRequestTracker = deps.createProviderRequestTracker;
         this.materializeRuntimeReplayPlan = deps.materializeRuntimeReplayPlan;
         this.canReplayProviderNative = deps.canReplayProviderNative;
-        this.appendTurnTailPrompt = deps.appendTurnTailPrompt;
     }
     /** Abort an in-flight manual history compaction (called by AiSdkBackend.stop). */
     abortHistoryCompact() {
@@ -409,7 +407,7 @@ export class AiSdkCompaction {
      * usage + a signed char/4 payload delta, tool schemas included) against
      * `contextWindow - reserve`; over the high-water, fold a safe completed
      * prefix into a durable mid_turn checkpoint and continue the same turn on
-     * `[compact block, verbatim head anchor, preserved tail]`.
+     * `[compact block, verbatim head anchor]`.
      *
      * This hook never terminates the turn: every failure fails open with a
      * diagnostic and records itself for the final-request estimate owner, which
@@ -420,7 +418,7 @@ export class AiSdkCompaction {
      * approximate — a missed or spurious trigger is recoverable; the verdict is
      * not, so it does not live here.
      */
-    buildMidTurnCapacityCompactProjection(turnId, state, queue, providerTools, fallbackActiveTools, turnTailPrompt, systemPromptChars, onDiagnosticPatch, origin, memoryCompactionDecision, onMemoryCompaction, abortSignal) {
+    buildMidTurnCapacityCompactProjection(turnId, state, queue, providerTools, fallbackActiveTools, systemPromptChars, onDiagnosticPatch, origin, memoryCompactionDecision, onMemoryCompaction, abortSignal) {
         if (!state)
             return undefined;
         const policy = this.input.contextBudget;
@@ -531,7 +529,6 @@ export class AiSdkCompaction {
                 providerTools,
                 activeToolsForStep,
                 systemPromptChars,
-                turnTailPrompt,
                 memoryCompactionDecision,
                 onMemoryCompaction,
                 abortSignal,
@@ -565,7 +562,7 @@ export class AiSdkCompaction {
      * the pass/terminate verdict and the diagnostic emission are the caller's.
      */
     async compactActiveRequestHistory(input) {
-        const { turnId, state, queue, providerTools, activeToolsForStep, systemPromptChars, turnTailPrompt, abortSignal, } = input;
+        const { turnId, state, queue, providerTools, activeToolsForStep, systemPromptChars, abortSignal, } = input;
         if (state.malformedSummaryFailure) {
             return {
                 decision: 'fail',
@@ -726,17 +723,7 @@ export class AiSdkCompaction {
                 diagnosticReason: 'replacement_unmaterializable',
             };
         }
-        // The head anchor must render exactly like the raw projection's current
-        // user message: the initial request decorates it with the volatile turn
-        // tail (cwd, shell context, task state — see send()), which is not part
-        // of the durable anchor bytes. Reuse the same decoration owner
-        // (appendTurnTailPrompt) on the anchor's replay item so a replacement
-        // never silently drops that context — and never counts the drop as
-        // shrinkage in the guard below.
-        const replayItemsWithAnchorTail = replayPlan.items.map((item) => item.kind === 'text' && item.role === 'user' && item.eventId === state.headAnchor.id
-            ? { ...item, content: this.appendTurnTailPrompt(item.content, turnTailPrompt) }
-            : item);
-        const replacementMessages = await this.materializeRuntimeReplayPlan({ ...replayPlan, items: replayItemsWithAnchorTail }, input.origin.imageBudget, plan.checkpoint);
+        const replacementMessages = await this.materializeRuntimeReplayPlan(replayPlan, input.origin.imageBudget, plan.checkpoint);
         // Apply the shape only when it actually shrinks the request versus the
         // reference payload (the incoming request for the proactive hook, the
         // request that overflowed for reactive recovery): a materialized
@@ -848,7 +835,6 @@ export class AiSdkCompaction {
             providerTools: input.providerTools,
             activeToolsForStep: input.activeTools,
             systemPromptChars: input.systemPromptChars,
-            turnTailPrompt: input.turnTailPrompt,
             memoryCompactionDecision: input.memoryCompactionDecision,
             onMemoryCompaction: input.onMemoryCompaction,
             abortSignal: input.abortSignal,

package/node_modules/@maka/runtime/dist/context-budget.js

@@ -93,7 +93,6 @@ export function buildPromptSegmentEstimates(input) {
                 : {}),
         },
         segment('current_user', input.currentUserContent.length, charsPerToken),
-        segment('turn_tail', input.turnTailPrompt?.length ?? 0, charsPerToken),
     ];
 }
 export function estimateModelMessagesChars(messages) {

package/node_modules/@maka/runtime/dist/plan-mode.js

@@ -83,68 +83,3 @@ export function renderPlanModePrompt(input = {}) {
         '</collaboration_mode>',
     ].join('\n');
 }
-export function renderInterruptedPlanContext(input) {
-    const steps = input.execution.steps.map((step) => renderExecutionStep(step)).join('\n');
-    return [
-        '<interrupted_plan_context>',
-        `Plan: ${input.proposal.title}`,
-        `Plan ID: ${input.proposal.planId}`,
-        `Proposal: ${input.proposal.proposalId} (revision ${input.proposal.revision})`,
-        `Interrupted execution ID: ${input.execution.executionId}`,
-        input.execution.interruptionReason
-            ? `Interruption reason: ${input.execution.interruptionReason}`
-            : '',
-        'Progress at interruption:',
-        steps,
-        input.fullAccess
-            ? 'The user entered Plan Mode to replan the remaining work. Do not resume the interrupted execution automatically. Full access remains active; modify files or perform side effects only when the user explicitly requests them during replanning. A submitted proposal will supersede this interrupted execution when approved.'
-            : 'The user entered Plan Mode to replan the remaining work. Do not resume execution or modify files. A submitted proposal will supersede this interrupted execution when approved.',
-        '</interrupted_plan_context>',
-    ]
-        .filter(Boolean)
-        .join('\n');
-}
-export function renderPlanExecutionPrompt(input) {
-    const steps = input.execution.steps.map((step) => renderExecutionStep(step)).join('\n');
-    return [
-        '<plan_execution_context>',
-        `Plan: ${input.proposal.title}`,
-        `Plan ID: ${input.proposal.planId}`,
-        `Proposal: ${input.proposal.proposalId} (revision ${input.proposal.revision})`,
-        `Execution ID: ${input.execution.executionId}`,
-        input.proposal.overview ? `Overview: ${input.proposal.overview}` : '',
-        'Approved steps:',
-        steps,
-        'Execute this approved plan. Before implementation, call update_plan with the first actionable step in_progress and every other step at its current status. Immediately after finishing a step, call update_plan again to mark it completed and move the next step to in_progress. Before the final response, update every finished or skipped step so the execution can close. If the user explicitly abandons the plan, call cancel_plan. Do not delegate to subagents while this execution is active.',
-        '</plan_execution_context>',
-    ]
-        .filter(Boolean)
-        .join('\n');
-}
-function statusMark(status) {
-    if (status === 'completed')
-        return 'x';
-    if (status === 'in_progress')
-        return '>';
-    if (status === 'skipped')
-        return '-';
-    return ' ';
-}
-function renderExecutionStep(step) {
-    return [
-        '<step>',
-        `<id>${escapeXml(step.id)}</id>`,
-        `<title>${escapeXml(step.title)}</title>`,
-        `<description>${escapeXml(step.description)}</description>`,
-        `<status>${step.status}</status>`,
-        '</step>',
-    ].join('\n');
-}
-function escapeXml(value) {
-    return value
-        .replaceAll('&', '&amp;')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replaceAll('"', '&quot;')
-        .replaceAll("'", '&apos;');
-}

package/node_modules/@maka/runtime/dist/run-trace.js

@@ -52,16 +52,6 @@ export class RunTrace {
             ...extra,
         });
     }
-    sandboxContextResolved(snapshot) {
-        this.emit('sandbox', 'sandbox_context_resolved', 'Sandbox context resolved', { snapshot });
-    }
-    sandboxContextFailed(stage, error) {
-        this.emit('sandbox', 'sandbox_context_failed', 'Sandbox context unavailable; continuing without prompt context', {
-            stage,
-            error: explainError(error),
-            ...diagnoseError(error),
-        });
-    }
     modelResolved() {
         this.emit('model', 'model_resolved', 'Model resolved', {
             connectionSlug: this.input.connectionSlug,

package/node_modules/@maka/runtime/dist/runtime-kernel.js

@@ -1689,7 +1689,6 @@ export class RuntimeKernel {
                     sessionId,
                 }),
                 allowMidTurnHistoryCompaction: Boolean(this.deps.runtimeEventStore),
-                shellRunContextSummary: () => this.deps.shellRuns?.buildContextSummary(sessionId) ?? Promise.resolve(undefined),
             });
             await this.rejectCancelledBackendActivation(backend, header, execution);
             const generation = this.createBackendGeneration(sessionId, backend, header);

package/node_modules/@maka/runtime/dist/sandbox/index.js

@@ -17,7 +17,6 @@
  * under the License.
  */
 export { SandboxManager } from './sandbox-manager.js';
-export { createSandboxDiagnosticsProvider, toSandboxRunTraceProjection, } from './diagnostics.js';
 export { SandboxCommandError, sandboxErrorMetadata, serializeSandboxError, } from './errors.js';
 export { createBuiltinSandboxManager, createDefaultSandboxManager, isBuiltinFilesystemWorkerSandboxAvailable, } from './default-sandbox-manager.js';
 export { LinuxBubblewrapBackend, buildBubblewrapArgv, buildNetworkSeccompFilter, discoverNestedProtectedMetadataPaths, } from './linux-sandbox.js';

package/node_modules/@maka/runtime/dist/sandbox/linux-sandbox.js

@@ -41,18 +41,6 @@ export class LinuxBubblewrapBackend {
     canEnforceProfile(profile) {
         return validateLinuxProfile(profile, this.options.arch ?? process.arch).ok;
     }
-    probe(request) {
-        const plan = this.plan(request);
-        if (!plan.ok)
-            return plan;
-        return {
-            ok: true,
-            executable: plan.bwrapPath,
-            sandboxType: 'linux',
-            requiresSandbox: true,
-            preference: plan.preference,
-        };
-    }
     transform(request) {
         const { command } = request;
         const plan = this.plan(request);

package/node_modules/@maka/runtime/dist/sandbox/macos-seatbelt.js

@@ -219,18 +219,6 @@ export function createSeatbeltExecArgs(input) {
 }
 export class MacosSeatbeltBackend {
     type = 'macos-seatbelt';
-    probe(request) {
-        const transformed = this.transform(request);
-        if (!transformed.ok)
-            return transformed;
-        return {
-            ok: true,
-            executable: MACOS_SEATBELT_EXECUTABLE,
-            sandboxType: transformed.sandboxType,
-            requiresSandbox: transformed.requiresSandbox,
-            preference: transformed.preference,
-        };
-    }
     transform(request) {
         const { command } = request;
         const preference = request.preference ?? 'auto';