maka-agent 0.2.0-dev.3.20260830 → 0.2.0-dev.31.20260913

package/node_modules/@maka/runtime/dist/session-projection-helpers.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { createHash } from 'node:crypto';
 import { failureClassFromCompleteStopReason } from '@maka/core/events';
 export function buildStatusPatch(status, ts, blockedReason) {
     return {
@@ -24,43 +25,28 @@ export function buildStatusPatch(status, ts, blockedReason) {
         statusUpdatedAt: ts,
     };
 }
-export function buildTurnStateMessage(input) {
-    const lineage = input.lineage ?? {};
-    return {
-        type: 'turn_state',
-        id: input.id,
-        turnId: input.turnId,
-        ts: input.ts,
-        status: input.status,
-        ...(lineage.parentTurnId ? { parentTurnId: lineage.parentTurnId } : {}),
-        ...(lineage.retriedFromTurnId ? { retriedFromTurnId: lineage.retriedFromTurnId } : {}),
-        ...(lineage.regeneratedFromTurnId
-            ? { regeneratedFromTurnId: lineage.regeneratedFromTurnId }
-            : {}),
-        ...(lineage.branchOfTurnId ? { branchOfTurnId: lineage.branchOfTurnId } : {}),
-        ...(lineage.parentSessionId ? { parentSessionId: lineage.parentSessionId } : {}),
-        ...(input.status === 'aborted' ? { abortedAt: input.ts } : {}),
-        ...(input.status === 'aborted' && input.abortSource ? { abortSource: input.abortSource } : {}),
-        ...(input.status === 'failed' ? { errorClass: input.errorClass ?? 'unknown' } : {}),
-        partialOutputRetained: input.partialOutputRetained,
-    };
-}
-export function turnHasRetainedOutput(messages, turnId) {
-    return messages.some((message) => (message.type === 'assistant' &&
-        message.turnId === turnId &&
-        message.text.trim().length > 0) ||
-        (message.type === 'tool_result' && message.turnId === turnId));
-}
-export function normalizeStopSessionSource(source) {
+export function normalizeStopSessionSource(source, workHubActionId) {
+    if (source !== 'workhub_direct_stop' && workHubActionId !== undefined) {
+        throw new Error('WorkHub direct-stop identity requires its dedicated Stop source');
+    }
     switch (source) {
         case 'stop_button':
             return 'renderer.stop_button';
         case 'graph_supervisor':
             return 'graph.supervisor';
+        case 'workhub_direct_stop':
+            return workHubDirectStopAbortSource(workHubActionId);
         case undefined:
             return undefined;
     }
 }
+export function workHubDirectStopAbortSource(actionId) {
+    if (!actionId || !/^[A-Za-z0-9_-]{1,128}$/u.test(actionId)) {
+        throw new Error('Invalid WorkHub direct-stop action identity');
+    }
+    const suffix = createHash('sha256').update(actionId, 'utf8').digest('hex').slice(0, 48);
+    return `workhub.direct_stop.${suffix}`;
+}
 export function isTerminalRunStatus(status) {
     return status === 'completed' || status === 'failed' || status === 'cancelled';
 }
@@ -69,12 +55,14 @@ export function statusFromEvent(event, options = {}) {
         case 'sandbox_boundary_request':
             return { status: 'waiting_for_user', blockedReason: 'permission_required' };
         case 'user_question_request':
+        case 'form_request':
             return { status: 'waiting_for_user' };
         case 'sandbox_boundary_decision_ack':
             if (options.allowInteractionResume === false)
                 return undefined;
             return { status: 'running' };
         case 'user_question_answer_ack':
+        case 'form_answer_ack':
             if (options.allowInteractionResume === false)
                 return undefined;
             return { status: 'running' };

package/node_modules/@maka/runtime/dist/session-recap.js

@@ -16,22 +16,25 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { runtimeEventHasModelVisibleContent } from '@maka/core/runtime-event';
 import { resolveSelectedModelContextWindow } from './context-budget-policy.js';
-import { groupEventsByTurn, stableJsonLength } from './context-budget-helpers.js';
+import { stableJsonLength } from './context-budget-helpers.js';
+import { groupEventsByTurn, formatTextWithInlineRefs } from './model-history.js';
 import { HistoryCompactSummarizerError } from './history-compact-error.js';
 import { fitHistoryCompactMessages } from './history-compact-input-fit.js';
-import { replayPlanItemsToModelMessages } from './history-compact-summarizer.js';
-import { buildRuntimeEventModelReplayPlan } from './model-history.js';
+const SESSION_RECAP_TOOL_OUTCOME_MAX_CHARS = 600;
 export const SESSION_RECAP_INSTRUCTION = '<system-reminder>The user is returning to this session after being away. Write ONE sentence (roughly 25-40 words) recapping where things stand so they can resume instantly. Write the sentence in the language of the user\'s most recent substantive message; for mixed-language sessions use the dominant language of the user\'s messages. Lead with agency, phrased naturally in that language: if the session was mainly questions or review with no landed change, open by referencing what the user asked (the equivalent of "You asked ..."); if the agent landed changes, reference what was done (the equivalent of "We fixed/added/wired ..."); if almost nothing happened, say in that language that the session had just begun. Output only the sentence - no labels, no quotes, no preamble.</system-reminder>';
 export function buildSessionRecapMessages(input) {
     const contextWindow = resolveSelectedModelContextWindow(input.connection, input.modelId);
-    let events = input.events;
     let maxEstimatedTokens;
+    let messages;
     if (contextWindow !== undefined) {
         maxEstimatedTokens = Math.max(0, Math.floor(contextWindow * 0.85) - 4_096);
-        events = recentTurnsWithinBudget(events, maxEstimatedTokens);
+        messages = recentRecapMessagesWithinBudget(input.events, maxEstimatedTokens);
+    }
+    else {
+        messages = projectSessionRecapMessages(input.events);
     }
-    let messages = replayPlanItemsToModelMessages(buildRuntimeEventModelReplayPlan(events).items);
     if (messages.length === 0 &&
         input.events.length > 0 &&
         maxEstimatedTokens !== undefined &&
@@ -43,21 +46,25 @@ export function buildSessionRecapMessages(input) {
     return messages;
 }
 /** Request-only recap projection; never mutates or replaces canonical history. */
-function recentTurnsWithinBudget(events, maxEstimatedTokens, charsPerToken = 4) {
+function recentRecapMessagesWithinBudget(events, maxEstimatedTokens, charsPerToken = 4) {
     const groups = groupEventsByTurn(events, charsPerToken);
-    const selected = [];
-    let selectedTokens = 0;
+    const selectedGroups = [];
+    let selectedChars = 2;
     for (let index = groups.length - 1; index >= 0; index -= 1) {
-        const group = groups[index];
-        if (selectedTokens + group.estimatedTokens > maxEstimatedTokens)
+        const projected = projectSessionRecapMessages(groups[index].events);
+        if (projected.length === 0)
+            continue;
+        const projectedChars = stableJsonLength(projected);
+        const candidateChars = selectedGroups.length === 0 ? projectedChars : projectedChars + selectedChars - 1;
+        if (candidateChars > maxEstimatedTokens * charsPerToken)
             break;
-        selected.unshift(group.events);
-        selectedTokens += group.estimatedTokens;
+        selectedGroups.push(projected);
+        selectedChars = candidateChars;
     }
-    return selected.flat();
+    return selectedGroups.reverse().flat();
 }
 function boundedOversizedTurnMessages(events, maxEstimatedTokens, charsPerToken = 4) {
-    const messages = replayPlanItemsToModelMessages(buildRuntimeEventModelReplayPlan(events).items);
+    const messages = projectSessionRecapMessages(events);
     try {
         return fitHistoryCompactMessages(messages, {
             maxInputEstimatedTokens: maxEstimatedTokens,
@@ -85,6 +92,71 @@ function boundedOversizedTurnMessages(events, maxEstimatedTokens, charsPerToken
     }
     return [];
 }
+function projectSessionRecapMessages(events) {
+    const messages = [];
+    for (const event of events) {
+        if (event.partial === true || !runtimeEventHasModelVisibleContent(event))
+            continue;
+        const content = event.content;
+        if (content?.kind === 'text' && (event.role === 'user' || event.role === 'model')) {
+            // The gate above already decided visibility through the shared
+            // predicate, which is satisfied by non-empty text or by the structured
+            // carriers — so every event reaching here projects, with its trimmed
+            // text and staged refs rendered by the shared inline-ref formatter.
+            messages.push({
+                role: event.role === 'user' ? 'user' : 'assistant',
+                content: formatTextWithInlineRefs({ ...content, text: content.text.trim() }),
+            });
+            continue;
+        }
+        if (content?.kind !== 'function_response')
+            continue;
+        const status = recapToolOutcomeStatus(content.isError === true, content.modelProjection);
+        const detail = recapToolOutcomeDetail(content.modelProjection);
+        messages.push({
+            role: 'assistant',
+            content: `Tool outcome (${content.name}, ${status})${detail ? `: ${detail}` : '.'}`,
+        });
+    }
+    return messages;
+}
+function recapToolOutcomeStatus(isError, projection) {
+    if (projection?.kind === 'execution_denied')
+        return 'denied';
+    if (isError ||
+        projection?.kind === 'failure' ||
+        ((projection?.kind === 'text' || projection?.kind === 'json') && projection.isError === true)) {
+        return 'failed';
+    }
+    return 'succeeded';
+}
+function recapToolOutcomeDetail(projection) {
+    if (!projection)
+        return '';
+    let detail;
+    switch (projection.kind) {
+        case 'text':
+            detail = projection.text;
+            break;
+        case 'json':
+            detail = JSON.stringify(projection.value);
+            break;
+        case 'content':
+            detail = projection.parts
+                .map((part) => part.kind === 'text'
+                ? part.text
+                : `[stored artifact: ${part.ref.kind === 'session_context' ? part.ref.refId : part.ref.relativePath}]`)
+                .join('\n');
+            break;
+        case 'execution_denied':
+            detail = projection.reason ?? '';
+            break;
+        case 'failure':
+            detail = projection.message;
+            break;
+    }
+    return boundedText(detail.trim(), SESSION_RECAP_TOOL_OUTCOME_MAX_CHARS);
+}
 function boundedTextMessage(role, text, maxEstimatedChars) {
     let low = 0;
     let high = text.length;

package/node_modules/@maka/runtime/dist/session-todo-tools.js

@@ -0,0 +1,67 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { SESSION_TODO_CONTENT_MAX_CHARS, SESSION_TODO_MAX_ITEMS, SESSION_TODO_STATUSES, sessionTodoContentForDisplay, } from '@maka/core/session-todo';
+import { z } from 'zod';
+export const TODO_READ_TOOL_NAME = 'todo_read';
+export const TODO_WRITE_TOOL_NAME = 'todo_write';
+export function buildSessionTodoTools(store) {
+    return [buildTodoReadTool(store), buildTodoWriteTool(store)];
+}
+function buildTodoReadTool(store) {
+    return {
+        name: TODO_READ_TOOL_NAME,
+        displayName: 'Todo Read',
+        description: 'Read the complete current session Todo list. Use this when you need the latest checklist.',
+        parameters: z.object({}).strict(),
+        impl: async (_input, ctx) => renderTodoSnapshot(await store.read(ctx.sessionId), 'read'),
+    };
+}
+function buildTodoWriteTool(store) {
+    return {
+        name: TODO_WRITE_TOOL_NAME,
+        displayName: 'Todo Write',
+        description: 'Atomically replace the complete current session Todo list. Include every item that should remain. ' +
+            'Completed means model-reported progress; it is not independently verified execution evidence.',
+        parameters: z
+            .object({
+            todos: z
+                .array(z
+                .object({
+                content: z
+                    .string()
+                    .trim()
+                    .min(1)
+                    .refine((content) => [...content.normalize('NFC')].length <= SESSION_TODO_CONTENT_MAX_CHARS, `Todo content must be ${SESSION_TODO_CONTENT_MAX_CHARS} characters or fewer`),
+                status: z.enum(SESSION_TODO_STATUSES),
+            })
+                .strict())
+                .max(SESSION_TODO_MAX_ITEMS),
+        })
+            .strict(),
+        impl: async (input, ctx) => renderTodoSnapshot(await store.replace(ctx.sessionId, input.todos), 'write'),
+    };
+}
+function renderTodoSnapshot(snapshot, operation) {
+    if (snapshot.items.length === 0) {
+        return operation === 'write' ? 'Todo list cleared.' : 'Todo list is empty.';
+    }
+    const lines = snapshot.items.map((item, index) => `${index + 1}. [${item.status}] ${JSON.stringify(sessionTodoContentForDisplay(item.content))}`);
+    const prefix = operation === 'write' ? 'Todo list updated' : 'Todo list';
+    return `${prefix} (${snapshot.items.length} items):\n${lines.join('\n')}`;
+}

package/node_modules/@maka/runtime/dist/session-trace-projection.js

@@ -18,7 +18,8 @@
  */
 import { dedupeModelCallAttempts, groupModelCallAttempts, } from '@maka/core/model-call-attempt';
 import { TERMINAL_RUNTIME_EVENT_STATUSES } from '@maka/core/runtime-event';
-import { SESSION_TRACE_SCHEMA_VERSION, traceTurnIdentityKey, } from '@maka/core/session-trace';
+import { SESSION_TRACE_SCHEMA_VERSION, MODEL_ATTEMPT_SHAPE, traceTurnIdentityKey, } from '@maka/core/session-trace';
+import { pickShape } from '@maka/core/record-schema';
 export function projectSessionTrace(input) {
     const events = input.runtimeEvents.filter((event) => !event.partial);
     // An aborted attempt and its later settlement are appended under one
@@ -189,35 +190,7 @@ function projectModelCallSteps(attempts) {
     return steps;
 }
 function toTraceAttempt(attempt) {
-    return {
-        attemptId: attempt.attemptId,
-        attempt: attempt.attempt,
-        status: attempt.status,
-        startedAt: attempt.startedAt,
-        completedAt: attempt.completedAt,
-        latencyMs: attempt.latencyMs,
-        ...(attempt.timeToFirstTokenMs !== undefined
-            ? { timeToFirstTokenMs: attempt.timeToFirstTokenMs }
-            : {}),
-        ...(attempt.finishReason !== undefined ? { finishReason: attempt.finishReason } : {}),
-        ...(attempt.errorClass !== undefined ? { errorClass: attempt.errorClass } : {}),
-        ...(attempt.httpStatus !== undefined ? { httpStatus: attempt.httpStatus } : {}),
-        ...(attempt.providerCode !== undefined ? { providerCode: attempt.providerCode } : {}),
-        ...(attempt.providerRequestId !== undefined
-            ? { providerRequestId: attempt.providerRequestId }
-            : {}),
-        ...(attempt.retryable !== undefined ? { retryable: attempt.retryable } : {}),
-        ...(attempt.inputTokens !== undefined ? { inputTokens: attempt.inputTokens } : {}),
-        ...(attempt.outputTokens !== undefined ? { outputTokens: attempt.outputTokens } : {}),
-        ...(attempt.cacheReadInputTokens !== undefined
-            ? { cacheReadInputTokens: attempt.cacheReadInputTokens }
-            : {}),
-        ...(attempt.reasoningTokens !== undefined ? { reasoningTokens: attempt.reasoningTokens } : {}),
-        ...(attempt.contextWindow !== undefined ? { contextWindow: attempt.contextWindow } : {}),
-        ...(attempt.costUsd !== undefined ? { costUsd: attempt.costUsd } : {}),
-        costBasis: attempt.costBasis,
-        usageBasis: attempt.usageBasis,
-    };
+    return pickShape(attempt, MODEL_ATTEMPT_SHAPE);
 }
 /** Prefix the runtime gives a written history-compaction boundary. */
 const HISTORY_COMPACT_EVENT_PREFIX = 'history-compact:';
@@ -226,6 +199,13 @@ function projectEventSteps(events) {
     const steps = [];
     const toolStarts = new Map();
     const toolStepsByOperation = new Map();
+    // A normal tool execution carries both a model function_call and the richer
+    // durable dispatch fact. Only calls with no dispatch anywhere in this turn
+    // belong to the generic lane; otherwise the Inspector would show duplicates.
+    const dispatchedToolCallIds = new Set(events.flatMap((event) => {
+        const dispatch = event.actions?.toolDispatch;
+        return dispatch ? [dispatch.providerToolCallId] : [];
+    }));
     for (const event of events) {
         // A written compaction boundary, which is not the same fact as the
         // summarizer call that produced its text: one is the checkpoint the next
@@ -254,6 +234,21 @@ function projectEventSteps(events) {
             }
             continue;
         }
+        const genericCall = event.content?.kind === 'function_call' ? event.content : undefined;
+        if (genericCall && !dispatchedToolCallIds.has(genericCall.id)) {
+            toolStarts.set(genericCall.id, { id: event.id, startedAt: event.ts });
+            steps.push({
+                kind: 'tool',
+                id: event.id,
+                turnId: event.turnId,
+                runId: event.runId,
+                startedAt: event.ts,
+                toolName: genericCall.name,
+                toolCallId: genericCall.id,
+                status: 'in_flight',
+            });
+            continue;
+        }
         const dispatch = event.actions?.toolDispatch;
         if (dispatch) {
             toolStarts.set(dispatch.providerToolCallId, { id: event.id, startedAt: event.ts });

package/node_modules/@maka/runtime/dist/shell-detect.js

@@ -26,9 +26,9 @@
 // the model is trapped writing `dir /s /b` style commands. This module detects
 // a better shell (pwsh > powershell > cmd) and carries the result to the two
 // places that need it: the spawn call (shell-exec / shell-run-manager) and the
-// prompt surfaces that must DECLARE the dialect to the model (tool description,
-// session environment fragment). Selection without declaration — or the other
-// way round — makes the model guess the dialect, which is the original bug.
+// Bash tool description that declares the dialect to the model. Selection
+// without declaration — or the other way round — makes the model guess the
+// dialect, which is the original bug.
 import { execFile } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { win32 } from 'node:path';
@@ -87,10 +87,6 @@ export function throwIfShellSetupFailed(shell) {
     if (shell.setupError)
         throw shell.setupError;
 }
-/** Model-facing shell name; a broken preference is declared, not silently hidden. */
-export function turnShellDisplayName(shell) {
-    return shell.setupError ? `Unavailable (${shell.setupError.message})` : shell.plan.displayName;
-}
 /** Rejects a persisted override unless the Host can execute it as GNU Bash. */
 export async function validateShellPreference(settings, input = {}) {
     const plan = resolveShellPlan(settings, input);

package/node_modules/@maka/runtime/dist/shell-exec.js

@@ -30,11 +30,11 @@ import { buildShellSpawnPlan, defaultShellPlan } from './shell-detect.js';
 import { BashTailBuffer } from './bash-tail-buffer.js';
 import { DEFAULT_PROCESS_TERMINATION_GRACE_MS } from './process-tree-terminator.js';
 import { DEFAULT_PROCESS_IO_DRAIN_TIMEOUT_MS, manageChildProcessLifecycle, } from './child-process-lifecycle.js';
-import { OUTPUT_RECOVERY_HINT } from './tool-output.js';
 import { buildSpawnStdio, closeChildFdSources, writeChildFdInputs, } from './child-fd-input.js';
 // Per-stream cap on the output RETAINED for the result (~1MB). This only bounds
-// what is kept to return. The tool layer (truncateToolOutput) trims this further
-// to the model's budget. Shared so both Bash paths retain identically.
+// what is kept to return. The tool layer preserves this result for durable
+// storage; unified result pruning bounds its model projection.
+// Shared so both Bash paths retain identically.
 export const BASH_MAX_RETAINED_CHARS = 1024 * 1024;
 // Per-stream cap on output forwarded LIVE via emitOutput (~1MB). The command is
 // never killed for size and the full recoverable tail is still RETAINED (above),
@@ -47,20 +47,6 @@ export const BASH_MAX_LIVE_EMIT_CHARS = 1024 * 1024;
 // not lost — it still feeds the retained tail and the returned result.
 export const LIVE_OUTPUT_SUPPRESSED_MARKER = '[live output suppressed: too much output to stream live; the command keeps ' +
     'running and its result still contains the most recent output]';
-// Appended to a stream when BashTailBuffer dropped an oversized line that had no
-// newline to truncate at (dropped whole for redaction safety). Without it, a
-// command whose only output was one giant line would look like it produced
-// nothing. Carries no dropped content — just a recoverable notice.
-const UNSAFE_DROP_MARKER = '[a single line larger than the output limit was omitted for safety. ' +
-    OUTPUT_RECOVERY_HINT +
-    ']';
-export function shellTailValueWithUnsafeDropMarker(buf) {
-    const text = buf.value(); // value() trims first, so the drop flag is current after it
-    if (!buf.hasDroppedUnsafe())
-        return text;
-    // Append (not prepend) so a later tail-keeping truncateToolOutput retains it.
-    return text ? `${text}\n${UNSAFE_DROP_MARKER}` : UNSAFE_DROP_MARKER;
-}
 /**
  * Run `command` in a shell, streaming output into a memory-bounded tail. Never
  * kills the command for producing too much output — it keeps only the last
@@ -213,8 +199,8 @@ function runSpawnedProcessWithBoundedTail(program, args, useShellOption, options
                 return;
             settled = true;
             cleanup();
-            const stdout = shellTailValueWithUnsafeDropMarker(stdoutBuf);
-            const stderr = shellTailValueWithUnsafeDropMarker(stderrBuf);
+            const stdout = stdoutBuf.value();
+            const stderr = stderrBuf.value();
             resolvePromise({
                 exitCode: termination
                     ? termination.timedOut
@@ -223,12 +209,8 @@ function runSpawnedProcessWithBoundedTail(program, args, useShellOption, options
                     : (outcome.exitCode ?? (outcome.signal ? 128 : 1)),
                 stdout,
                 stderr,
-                stdoutTruncated: outcome.incompleteOutputs.has('stdout') ||
-                    stdoutChars > stdout.length ||
-                    stdoutBuf.hasDroppedUnsafe(),
-                stderrTruncated: outcome.incompleteOutputs.has('stderr') ||
-                    stderrChars > stderr.length ||
-                    stderrBuf.hasDroppedUnsafe(),
+                stdoutTruncated: outcome.incompleteOutputs.has('stdout') || stdoutChars > stdout.length,
+                stderrTruncated: outcome.incompleteOutputs.has('stderr') || stderrChars > stderr.length,
                 timedOut: !!termination?.timedOut,
                 aborted: !!termination?.aborted,
             });

package/node_modules/@maka/runtime/dist/shell-run-contract.js

@@ -32,7 +32,6 @@ export const DEFAULT_MAX_LIVE_PTY_RUNS = 8;
 export const DEFAULT_SHELL_RUN_FLUSH_INTERVAL_MS = 1_000;
 export const DEFAULT_SHELL_RUN_FLUSH_BYTES = 64 * 1024;
 export const DEFAULT_PIPE_OUTPUT_DRAIN_MS = 2_000;
-export const SHELL_RUN_CONTEXT_SUMMARY_LIMIT = 8;
 export const SHELL_RUN_RESOURCE_PREFIX = 'maka://runtime/background-tasks';
 export const MAX_SHELL_RUN_RESOURCE_REF_CHARS = SHELL_RUN_RESOURCE_PREFIX.length + 1 + SHELL_RUN_ID_MAX_CHARS;
 export { isWellFormedTerminalInput };

package/node_modules/@maka/runtime/dist/shell-run-manager.js

@@ -30,7 +30,7 @@ import { PipeTailCollector } from './pipe-tail-collector.js';
 import { PtyProcessDriver } from './pty-process-driver.js';
 import { PTY_INITIAL_COLS, PTY_INITIAL_ROWS, PtyScreenCollector, } from './pty-screen-collector.js';
 import { loadPtyStack } from './pty-stack.js';
-import { DEFAULT_BASH_TIMEOUT_MS, DEFAULT_MAX_LIVE_PTY_RUNS, DEFAULT_MAX_LIVE_SHELL_RUNS, DEFAULT_PIPE_OUTPUT_DRAIN_MS, DEFAULT_SHELL_RUN_FLUSH_BYTES, DEFAULT_SHELL_RUN_FLUSH_INTERVAL_MS, MAX_FOREGROUND_BASH_TIMEOUT_MS, MAX_SHELL_RUN_TIMEOUT_MS, SHELL_RUN_CONTEXT_SUMMARY_LIMIT, ShellRunPtyControlClosedError, parseShellRunResourceRef, shellRunResourceRef, validateWriteStdinInput, } from './shell-run-contract.js';
+import { DEFAULT_BASH_TIMEOUT_MS, DEFAULT_MAX_LIVE_PTY_RUNS, DEFAULT_MAX_LIVE_SHELL_RUNS, DEFAULT_PIPE_OUTPUT_DRAIN_MS, DEFAULT_SHELL_RUN_FLUSH_BYTES, DEFAULT_SHELL_RUN_FLUSH_INTERVAL_MS, MAX_FOREGROUND_BASH_TIMEOUT_MS, MAX_SHELL_RUN_TIMEOUT_MS, ShellRunPtyControlClosedError, parseShellRunResourceRef, shellRunResourceRef, validateWriteStdinInput, } from './shell-run-contract.js';
 import { compactShellRunContent, ptyControlOperation, shellRunContent, shellRunUpdate, terminalContent, } from './shell-run-tool-result.js';
 import { CompletionLatch } from './completion-latch.js';
 import { closeChildFdSources } from './child-fd-input.js';
@@ -404,30 +404,6 @@ export class ShellRunProcessManager {
         const record = await this.markObserved(await live.finished.join());
         return shellRunContent(record, { kind: 'stop', applied });
     }
-    async buildContextSummary(sessionId) {
-        const records = (await this.actionableRecords(sessionId)).filter((record) => record.visibility !== 'user');
-        if (records.length === 0)
-            return undefined;
-        const visible = records.slice(0, SHELL_RUN_CONTEXT_SUMMARY_LIMIT);
-        const lines = [
-            'Background tasks for this session:',
-            ...visible.map((record) => {
-                const completed = record.completedAt !== undefined ? ` completedAt=${record.completedAt}` : '';
-                return `- ref=${shellRunResourceRef(record.shellRunId)} mode=${record.output.mode} status=${record.status} cwd=${record.cwd} updatedAt=${record.updatedAt}${completed} command=${JSON.stringify(record.command)}`;
-            }),
-        ];
-        const overflow = records.length - visible.length;
-        if (overflow > 0)
-            lines.push(`- ${overflow} more background task(s) not shown in this turn tail.`);
-        const hasControllablePty = records.some((record) => {
-            const live = this.liveResource(sessionId, record.shellRunId);
-            return live?.mode === 'pty' && isPtyControlOpen(live);
-        });
-        lines.push(hasControllablePty
-            ? 'Use Read on a ref for its bounded output snapshot; use WriteStdin to control a running PTY task.'
-            : 'Use Read on a ref for its bounded output snapshot.');
-        return lines.join('\n');
-    }
     async listSessionUpdates(sessionId) {
         const records = await this.input.store.listSessionShellRuns(sessionId);
         return records.map(shellRunUpdate);
@@ -739,7 +715,7 @@ export class ShellRunProcessManager {
             sourceToolCallId: input.sourceToolCallId,
             ...(input.visibility === undefined ? {} : { visibility: input.visibility }),
             cwd: input.cwd,
-            command: redactSecrets(input.command),
+            command: input.command,
             status: 'starting',
             startedAt,
             updatedAt: startedAt,
@@ -1483,13 +1459,6 @@ export class ShellRunProcessManager {
             return this.input.store.updateShellRun(current.sessionId, current.shellRunId, buildPatch());
         }
     }
-    async actionableRecords(sessionId) {
-        const records = await this.input.store.listSessionShellRuns(sessionId);
-        return records
-            .filter((record) => isActiveShellRunStatus(record.status) ||
-            (record.observedAt === undefined && isTerminalShellRunStatus(record.status)))
-            .sort(compareActionableShellRuns);
-    }
     notifyShellRunUpdate(record) {
         try {
             this.input.onShellRunUpdate?.(shellRunUpdate(record));
@@ -1679,13 +1648,6 @@ function startupCleanupError(startupError, cleanupFailure) {
     const cleanupError = asError(cleanupFailure, 'Shell process startup cleanup failed');
     return new Error(`Shell process startup failed: ${safeFailureMessage(startupError)}; startup cleanup failed: ${safeFailureMessage(cleanupError)}`, { cause: new AggregateError([startupError, cleanupError]) });
 }
-function compareActionableShellRuns(a, b) {
-    const rank = (record) => (isActiveShellRunStatus(record.status) ? 1 : 0);
-    return (rank(a) - rank(b) ||
-        b.updatedAt - a.updatedAt ||
-        b.startedAt - a.startedAt ||
-        a.shellRunId.localeCompare(b.shellRunId));
-}
 async function racePromiseWithAbort(promise, signal) {
     if (!signal)
         return promise;
@@ -1715,13 +1677,16 @@ function normalizeBackgroundTimeoutMs(value) {
     }
     return value;
 }
-function splitPtyData(data) {
-    const codePoints = Array.from(data);
-    const chunks = [];
-    for (let offset = 0; offset < codePoints.length; offset += PTY_RAW_INPUT_CHUNK_CODE_POINTS) {
-        chunks.push(codePoints.slice(offset, offset + PTY_RAW_INPUT_CHUNK_CODE_POINTS).join(''));
+function* splitPtyData(data) {
+    // Bound each published piece without materializing the entire callback as code points.
+    let offset = 0;
+    while (offset < data.length) {
+        const start = offset;
+        for (let count = 0; count < PTY_RAW_INPUT_CHUNK_CODE_POINTS && offset < data.length; count++) {
+            offset += data.codePointAt(offset) > 0xffff ? 2 : 1;
+        }
+        yield data.slice(start, offset);
     }
-    return chunks;
 }
 function encodedPtyDataBytes(data) {
     return Buffer.byteLength(JSON.stringify(data), 'utf8');

package/node_modules/@maka/runtime/dist/shell-run-tool-result.js

@@ -43,7 +43,7 @@ export function terminalContent(record) {
         status: terminalResultStatus(record.status),
         ...(record.exitCode !== undefined ? { exitCode: record.exitCode } : {}),
         ...(record.failureMessage !== undefined ? { failureMessage: record.failureMessage } : {}),
-        output: projectShellOutputForModel(record.output),
+        output: record.output,
         ...(sandboxDenialForRecord(record) ? { sandboxDenial: sandboxDenialForRecord(record) } : {}),
     };
 }
@@ -212,16 +212,23 @@ function takeTailText(text, budget) {
     return { text: `${TRUNCATED_MARKER}\n${tail}`, truncated: true };
 }
 function sliceUtf8Tail(text, budget) {
-    const characters = Array.from(text);
-    let result = '';
+    const characters = [];
     let bytes = 0;
-    for (let index = characters.length - 1; index >= 0; index -= 1) {
-        const character = characters[index];
+    for (let end = text.length; end > 0;) {
+        let start = end - 1;
+        const last = text.charCodeAt(start);
+        if (last >= 0xdc00 && last <= 0xdfff && start > 0) {
+            const previous = text.charCodeAt(start - 1);
+            if (previous >= 0xd800 && previous <= 0xdbff)
+                start -= 1;
+        }
+        const character = text.slice(start, end);
         const size = Buffer.byteLength(character, 'utf8');
         if (bytes + size > budget)
             break;
-        result = character + result;
+        characters.push(character);
         bytes += size;
+        end = start;
     }
-    return result;
+    return characters.reverse().join('');
 }