maka-agent 0.2.0-dev.64.20260929 → 0.2.0-dev.67.20261002

package/LICENSE

@@ -253,7 +253,7 @@ License: MIT
 
 Maka includes an ejected adaptation of Astryx ChatReasoning v0.1.9 in
 `packages/ui/src/astryx-chat-reasoning.tsx` and generated theme artifacts in
-`apps/desktop/src/renderer/astryx-theme/`, based on Astryx theme-neutral v0.6.2.
+`apps/desktop/src/renderer/astryx-theme/`, based on Astryx theme-neutral v0.6.3.
 Maka also redistributes
 `patches/@astryxdesign+core+0.6.3.patch`, which modifies the MIT-licensed Astryx
 core package. The following MIT License applies to that material:

package/THIRD_PARTY_NOTICES.txt

@@ -2304,7 +2304,7 @@ SOFTWARE.
 
 ================================================================================
 
-Package: axios@1.18.1
+Package: axios@1.20.0
 Declared license: MIT
 Selected license: MIT
 Repository: https://github.com/axios/axios.git
@@ -3004,7 +3004,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 ================================================================================
 
-Package: brace-expansion@5.0.9
+Package: brace-expansion@5.0.12
 Declared license: MIT
 Selected license: MIT
 Repository: git+https://github.com/juliangruber/brace-expansion.git
@@ -3970,7 +3970,7 @@ SOFTWARE.
 
 ================================================================================
 
-Package: fast-uri@3.1.7
+Package: fast-uri@3.1.8
 Declared license: BSD-3-Clause
 Selected license: BSD-3-Clause
 Repository: git+https://github.com/fastify/fast-uri.git

package/dist/pi-tui-runner.js

@@ -786,7 +786,7 @@ export async function runMakaPiTui(input) {
         return true;
     };
     // Refill the editor from a retract result, prepended to any current draft.
-    // Shared by the interrupt path and the alt+↑ path. The text always comes
+    // Shared by the interrupt path and the Shift+← path. The text always comes
     // from `driver.retractQueued()` — an authoritative queue mutation — never
     // from the render mirror, which can
     // lag a step-boundary consumption and would resurrect an already-consumed
@@ -879,7 +879,7 @@ export async function runMakaPiTui(input) {
             return;
         }
         // First-run has no connection, so the wizard is the only surface. This is
-        // the single choke point for idle submits (Enter, Alt+Enter, steer
+        // the single choke point for idle submits (Enter, steer
         // fallback): reopen the wizard instead of opening a turn against a
         // connection-less driver. Slash commands above already routed to the
         // command layer (/exit still exits, /help still shows help).
@@ -959,29 +959,16 @@ export async function runMakaPiTui(input) {
         }
         submitMessage(text, 'current_turn');
     };
-    // Alt+Enter: during a turn, queue the text to open the next turn; when idle,
-    // it submits like Enter.
-    const handleAltEnter = () => {
-        // Mirror Enter's control-busy guard BEFORE touching the editor: during a
-        // control action (busy without a running turn) submitPrompt would drop the
-        // prompt, so keep the draft in place instead of clearing it into the void.
-        if (busy && !turnRunning)
-            return;
-        // Interrupt convergence window: the turn is being stopped, so nothing may
-        // be queued onto it and no fresh turn may open — keep the draft.
-        if (interruptRequested)
-            return;
+    // Tab: during a turn, queue the draft to open the next turn. Idle Tab never
+    // reaches this — it stays the editor's completion trigger (key handler gate).
+    const queueDraftForNextTurn = () => {
         const text = editor.getExpandedText().trim();
         if (!text)
             return;
         editor.setText('');
-        if (!turnRunning) {
-            submitPrompt(text);
-            return;
-        }
         submitMessage(text, 'next_turn');
     };
-    // Alt+↑: take back every queued message from the Runtime Host, joined and
+    // Shift+←: take back every queued message from the Runtime Host, joined and
     // prepended to the current draft for re-editing.
     const retractQueuedMessages = () => {
         void (async () => {
@@ -4119,20 +4106,30 @@ export async function runMakaPiTui(input) {
             }
             return { consume: true };
         }
-        // Alt+Enter: queue a followup (during a turn) or submit (when idle). Alt+↑:
-        // take back the queued messages to re-edit. Neither is an editor binding
-        // (newline is shift+enter/ctrl+j; history is plain up), so intercepting
-        // here does not collide with the editor's own keys.
-        if (matchesKey(data, Key.alt('enter')) && !isKeyRepeat(data)) {
-            handleAltEnter();
+        // Tab: queue a followup during a turn — the route terminals deliver
+        // reliably, unlike the Alt chords they claim for themselves (#3538;
+        // Codex's default). The editor owns Tab everywhere else: it
+        // triggers/accepts completion, so a turn-running Tab only queues a
+        // non-empty draft while no completion popup is open. Idle Tab stays
+        // with the editor rather than submitting.
+        if (turnRunning &&
+            !interruptRequested &&
+            !editorPastePending &&
+            editor.getText().trim().length > 0 &&
+            !editor.isShowingAutocomplete() &&
+            matchesKey(data, Key.tab) &&
+            !isKeyRepeat(data)) {
+            queueDraftForNextTurn();
             return { consume: true };
         }
-        if (matchesKey(data, Key.alt('up')) && !isKeyRepeat(data)) {
+        // Shift+←: retract queued messages (Codex's edit_queued_message
+        // default). Not an editor binding, and an empty retract refill is a
+        // no-op, so consuming unconditionally loses nothing — same rationale
+        // the old Alt+↑ binding used.
+        if (matchesKey(data, Key.shift('left')) && !isKeyRepeat(data)) {
             // Always retract from the authority: the render mirror lags the
-            // queue_update event, so an enqueue followed by Alt+Up in the same
+            // queue_update event, so an enqueue followed by Shift+← in the same
             // tick would see an empty mirror while the runtime holds the message.
-            // Alt+Up is not an editor binding, and an empty retract refill is a
-            // no-op, so consuming unconditionally loses nothing.
             retractQueuedMessages();
             return { consume: true };
         }

package/dist/tui-copy-catalog.js

@@ -1032,8 +1032,8 @@ export const TUI_COPY_RESOURCES = {
                     '  Ctrl+T — expand or collapse all thinking in view',
                     '  Scroll the transcript with your terminal or trackpad',
                     '  Enter (during a turn) — steer: inject a message into the running turn',
-                    '  Alt+Enter (during a turn) — queue a message for the next turn',
-                    '  Alt+↑ — take queued messages back into the editor to re-edit',
+                    '  Tab (during a turn) — queue a message for the next turn',
+                    '  Shift+← — take queued messages back into the editor to re-edit',
                     '  Esc Esc (during a turn) — interrupt the turn',
                     '  Esc Esc (when idle) — rewind to an earlier turn',
                     '  Ctrl+C — stop the turn, clear input, or press twice to exit',
@@ -1086,8 +1086,8 @@ export const TUI_COPY_RESOURCES = {
                     '  Ctrl+T — 展开或折叠视图中的所有思考块',
                     '  使用终端或触控板滚动对话记录',
                     '  Enter（任务运行中）— 将消息注入当前任务',
-                    '  Alt+Enter（任务运行中）— 将消息排入下一轮',
-                    '  Alt+↑ — 将已排队消息取回编辑器重新编辑',
+                    '  Tab（任务运行中）— 将消息排入下一轮',
+                    '  Shift+← — 将已排队消息取回编辑器重新编辑',
                     '  Esc Esc（任务运行中）— 中断当前任务',
                     '  Esc Esc（空闲时）— 回退到较早的轮次',
                     '  Ctrl+C — 停止任务、清空输入，或连续按两次退出',
@@ -1140,8 +1140,8 @@ export const TUI_COPY_RESOURCES = {
                     '  Ctrl+T — 展開或摺疊檢視中的所有思考區塊',
                     '  使用終端機或觸控板捲動對話記錄',
                     '  Enter（任務執行中）— 將訊息注入目前任務',
-                    '  Alt+Enter（任務執行中）— 將訊息排入下一輪',
-                    '  Alt+↑ — 將已排隊訊息取回編輯器重新編輯',
+                    '  Tab（任務執行中）— 將訊息排入下一輪',
+                    '  Shift+← — 將已排隊訊息取回編輯器重新編輯',
                     '  Esc Esc（任務執行中）— 中斷目前任務',
                     '  Esc Esc（空閒時）— 回退到較早的輪次',
                     '  Ctrl+C — 停止任務、清空輸入，或連續按兩次退出',
@@ -1372,17 +1372,17 @@ export const TUI_COPY_RESOURCES = {
         en: {
             steeringLabel: 'Steering:',
             queuedLabel: 'Queued:',
-            requeueHint: 'Alt+↑ take queued messages back to re-edit',
+            requeueHint: 'Shift+← take queued messages back to re-edit',
         },
         'zh-CN': {
             steeringLabel: '注入：',
             queuedLabel: '已排队：',
-            requeueHint: 'Alt+↑ 取回队列以重新编辑',
+            requeueHint: 'Shift+← 取回队列以重新编辑',
         },
         'zh-TW': {
             steeringLabel: '調整方向：',
             queuedLabel: '已排入佇列：',
-            requeueHint: 'Alt+↑ 取回佇列訊息重新編輯',
+            requeueHint: 'Shift+← 取回佇列訊息重新編輯',
         },
     },
     'session-status': {

package/node_modules/@maka/core/dist/settings.js

@@ -340,7 +340,7 @@ export function createDefaultSettings() {
             activeTab: 'requests',
         },
         appearance: {
-            workbarTogglePosition: 'edge',
+            workbarTogglePosition: 'titlebar',
             theme: 'auto',
             palette: 'default',
             appIcon: DEFAULT_APP_ICON,
@@ -517,7 +517,7 @@ export function normalizeSettings(input) {
         // position; UI density is no longer a product setting.
         appearance: {
             ...appearanceWithoutLegacyFields,
-            workbarTogglePosition: base.appearance.workbarTogglePosition === 'titlebar' ? 'titlebar' : 'edge',
+            workbarTogglePosition: base.appearance.workbarTogglePosition === 'edge' ? 'edge' : 'titlebar',
             palette: isThemePalette(base.appearance.palette) ? base.appearance.palette : 'default',
             // Same fail-closed rule as `palette` above, for the same reason: an
             // unknown id would otherwise reach the main process and resolve to a

package/node_modules/@maka/core/dist/tool-ledger-scanner.js

@@ -132,37 +132,46 @@ export function validateGenericToolLedgerAppend(event) {
  */
 export function validateToolLedgerTransition(input) {
     const reducer = new ToolLedgerReducer(input.existingEvents);
-    const validation = validateIncrementalToolLedgerTransition({
-        reducer,
-        candidateEvents: input.candidateEvents,
-        expectedTransition: input.expectedTransition,
-    });
-    if (validation.ok) {
-        reducer.commit(validation.checkpoint);
-        return { ok: true };
+    const existing = reducer.scan();
+    if (existing.hasCorruption) {
+        return { source: 'existing', ...issueValidation(existing.issues[0]) };
+    }
+    const candidates = [];
+    for (const candidate of input.candidateEvents) {
+        const prior = reducer.event(candidate.id);
+        if (!prior) {
+            candidates.push(candidate);
+            continue;
+        }
+        if (!nodeUtil.isDeepStrictEqual(prior, candidate)) {
+            return {
+                ok: false,
+                source: 'candidate',
+                code: 'duplicate_event_id',
+                eventId: candidate.id,
+            };
+        }
     }
-    const { source: _source, ...failure } = validation;
-    return failure;
+    const shape = validateTransitionShape(candidates, input.expectedTransition);
+    if (!shape.ok)
+        return { source: 'candidate', ...shape };
+    reducer.append(candidates);
+    const issue = reducer.scan().issues[0];
+    return issue ? { source: 'candidate', ...issueValidation(issue) } : { ok: true };
 }
 /**
- * Stateful interpretation of an immutable RuntimeEvent prefix.
- *
- * Candidate appends mutate the reducer behind a checkpoint. The caller either
- * commits that checkpoint after durable transaction commit or rolls it back.
- * Rollback records only the fields touched by the candidate batch, so a small
- * append does not clone maps proportional to the full checked prefix.
+ * Invocation-scoped interpretation shared by scans and prospective validation.
+ * Each caller owns a fresh reducer; no state survives a validation call.
  */
-export class ToolLedgerReducer {
+class ToolLedgerReducer {
     operations = [];
     issues = [];
     eventsById = new Map();
     byToolCall = new Map();
     byOperation = new Map();
     invocationSpines = new Map();
-    undoLog = [];
-    recordUndo = false;
-    constructor(events = []) {
-        this.consume(events, false);
+    constructor(events) {
+        this.append(events);
     }
     scan() {
         const dependencyIssues = this.toolDependencyIssues();
@@ -195,45 +204,16 @@ export class ToolLedgerReducer {
     event(eventId) {
         return this.eventsById.get(eventId);
     }
-    checkpoint() {
-        return this.undoLog.length;
-    }
     append(events) {
-        this.consume(events, true);
-    }
-    rollback(checkpoint) {
-        this.assertCheckpoint(checkpoint);
-        for (let index = this.undoLog.length - 1; index >= checkpoint; index -= 1) {
-            this.undoLog[index]();
-        }
-        this.undoLog.length = checkpoint;
-    }
-    commit(checkpoint) {
-        this.assertCheckpoint(checkpoint);
-        this.undoLog.length = checkpoint;
-    }
-    assertCheckpoint(checkpoint) {
-        if (!Number.isSafeInteger(checkpoint) || checkpoint < 0 || checkpoint > this.undoLog.length) {
-            throw new RangeError('Invalid tool ledger reducer checkpoint');
-        }
-    }
-    consume(events, recordUndo) {
-        const previous = this.recordUndo;
-        this.recordUndo = recordUndo;
-        try {
-            for (const event of events)
-                this.consumeEvent(event);
-        }
-        finally {
-            this.recordUndo = previous;
-        }
+        for (const event of events)
+            this.consumeEvent(event);
     }
     consumeEvent(event) {
         if (this.eventsById.has(event.id)) {
             this.addIssue(undefined, { code: 'duplicate_event_id', eventId: event.id });
             return;
         }
-        this.setMap(this.eventsById, event.id, event);
+        this.eventsById.set(event.id, event);
         const spine = JSON.stringify([event.sessionId, event.runId, event.turnId]);
         const existingSpine = this.invocationSpines.get(event.invocationId);
         if (existingSpine !== undefined && existingSpine !== spine) {
@@ -243,7 +223,7 @@ export class ToolLedgerReducer {
             });
         }
         else {
-            this.setMap(this.invocationSpines, event.invocationId, spine);
+            this.invocationSpines.set(event.invocationId, spine);
         }
         const lane = validateToolLedgerEventLane(event);
         if (!lane.ok) {
@@ -260,7 +240,7 @@ export class ToolLedgerReducer {
             const existing = this.byToolCall.get(toolCallKey);
             if (existing) {
                 if (!existing.callEvent) {
-                    this.setOperationField(existing, 'callEvent', event);
+                    existing.callEvent = event;
                     if (existing.toolName !== content.name) {
                         this.addIssue(existing, {
                             code: 'identity_conflict',
@@ -287,8 +267,8 @@ export class ToolLedgerReducer {
                 decisionEvents: [],
                 issues: [],
             };
-            this.setMap(this.byToolCall, toolCallKey, operation);
-            this.push(this.operations, operation);
+            this.byToolCall.set(toolCallKey, operation);
+            this.operations.push(operation);
             return;
         }
         if (lane.lane === 'tool_dispatch') {
@@ -307,8 +287,8 @@ export class ToolLedgerReducer {
                     decisionEvents: [],
                     issues: [],
                 };
-                this.setMap(this.byToolCall, toolCallKey, operation);
-                this.push(this.operations, operation);
+                this.byToolCall.set(toolCallKey, operation);
+                this.operations.push(operation);
                 this.addIssue(operation, {
                     code: 'event_order_conflict',
                     eventId: event.id,
@@ -333,14 +313,14 @@ export class ToolLedgerReducer {
                     operationId: dispatch.operationId,
                     toolCallId: dispatch.providerToolCallId,
                 };
-                this.push(this.issues, issue);
-                this.push(existingOperation.issues, issue);
-                this.push(operation.issues, issue);
+                this.issues.push(issue);
+                existingOperation.issues.push(issue);
+                operation.issues.push(issue);
                 return;
             }
-            this.setOperationField(operation, 'operationId', dispatch.operationId);
-            this.setOperationField(operation, 'dispatchEvent', event);
-            this.setMap(this.byOperation, dispatch.operationId, operation);
+            operation.operationId = dispatch.operationId;
+            operation.dispatchEvent = event;
+            this.byOperation.set(dispatch.operationId, operation);
             if (operation.toolName !== dispatch.toolName ||
                 event.refs?.operationId !== dispatch.operationId ||
                 event.refs?.toolCallId !== dispatch.providerToolCallId ||
@@ -406,8 +386,8 @@ export class ToolLedgerReducer {
                     decisionEvents: [],
                     issues: [],
                 };
-                this.push(this.operations, orphan);
-                this.setMap(this.byToolCall, toolCallKey, orphan);
+                this.operations.push(orphan);
+                this.byToolCall.set(toolCallKey, orphan);
                 this.addIssue(orphan, {
                     code: 'orphan_response',
                     eventId: event.id,
@@ -424,7 +404,7 @@ export class ToolLedgerReducer {
                 });
                 return;
             }
-            this.setOperationField(operation, 'responseEvent', event);
+            operation.responseEvent = event;
             if (operation.toolName !== content.name ||
                 !sameExecutionIdentity(operation.callEvent, event) ||
                 (operation.operationId !== undefined &&
@@ -454,48 +434,15 @@ export class ToolLedgerReducer {
                 return;
             }
             if (lane.lane === 'reconcile_result')
-                this.push(operation.reconcileEvents, event);
+                operation.reconcileEvents.push(event);
             else
-                this.push(operation.decisionEvents, event);
+                operation.decisionEvents.push(event);
         }
     }
     addIssue(operation, issue) {
-        this.push(this.issues, issue);
+        this.issues.push(issue);
         if (operation)
-            this.push(operation.issues, issue);
-    }
-    push(values, value) {
-        const length = values.length;
-        this.undo(() => {
-            values.length = length;
-        });
-        values.push(value);
-    }
-    setMap(values, key, value) {
-        const had = values.has(key);
-        const previous = values.get(key);
-        this.undo(() => {
-            if (had)
-                values.set(key, previous);
-            else
-                values.delete(key);
-        });
-        values.set(key, value);
-    }
-    setOperationField(operation, key, value) {
-        const had = Object.hasOwn(operation, key);
-        const previous = operation[key];
-        this.undo(() => {
-            if (had)
-                operation[key] = previous;
-            else
-                delete operation[key];
-        });
-        operation[key] = value;
-    }
-    undo(operation) {
-        if (this.recordUndo)
-            this.undoLog.push(operation);
+            operation.issues.push(issue);
     }
     toolDependencyIssues() {
         const result = [];
@@ -579,53 +526,9 @@ export class ToolLedgerReducer {
         return result;
     }
 }
-/**
- * Applies one prospective writer batch to a checked prefix. A successful call
- * leaves the candidate delta applied until the caller commits or rolls back the
- * returned checkpoint. A rejected candidate restores the reducer immediately.
- */
-export function validateIncrementalToolLedgerTransition(input) {
-    const existing = input.reducer.scan();
-    if (existing.hasCorruption) {
-        return { source: 'existing', ...issueValidation(existing.issues[0]) };
-    }
-    const candidates = [];
-    for (const candidate of input.candidateEvents) {
-        const prior = input.reducer.event(candidate.id);
-        if (!prior) {
-            candidates.push(candidate);
-            continue;
-        }
-        if (!nodeUtil.isDeepStrictEqual(prior, candidate)) {
-            return {
-                ok: false,
-                source: 'candidate',
-                code: 'duplicate_event_id',
-                eventId: candidate.id,
-            };
-        }
-    }
-    const shape = validateTransitionShape(candidates, input.expectedTransition);
-    if (!shape.ok)
-        return { source: 'candidate', ...shape };
-    const checkpoint = input.reducer.checkpoint();
-    try {
-        input.reducer.append(candidates);
-    }
-    catch (error) {
-        input.reducer.rollback(checkpoint);
-        throw error;
-    }
-    const issue = input.reducer.scan().issues[0];
-    if (issue) {
-        input.reducer.rollback(checkpoint);
-        return { source: 'candidate', ...issueValidation(issue) };
-    }
-    return { ok: true, checkpoint, appendedEvents: candidates.length };
-}
 /**
  * Scans immutable RuntimeEvents once, in physical ledger order. Resolver,
- * projection rebuild and incremental writers all use the same reducer rules.
+ * projection rebuild and prospective writers all use the same reducer rules.
  */
 export function scanToolLedger(events) {
     return new ToolLedgerReducer(events).scan();

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

@@ -132,7 +132,14 @@ export class AiSdkCompaction {
             if (previousCheckpoint) {
                 const match = matchHistoryCompactCheckpointPrefix(previousCheckpoint, runtimeContext);
                 if (!match.reason && match.successorRuntimeEvents.length === 0) {
-                    {
+                    // Raw identity is not enough: a projection transition committed
+                    // after the fold rewrites the covered span's effective view without
+                    // touching the raw ledger, so reuse requires the pinned effective
+                    // digest to still match — the same gate the pre-send path applies
+                    // (#5929). On drift, fall through to the planner, whose roll-forward
+                    // currency check discards the stale checkpoint and re-summarizes.
+                    const effectiveCovered = await this.foldEffectiveModelHistory(match.coveredRuntimeEvents);
+                    if (this.checkpointEffectiveCoverageMatches(previousCheckpoint, effectiveCovered)) {
                         const projectedEvents = projectHistoryCompactCheckpointReplay(previousCheckpoint, match.coveredRuntimeEvents, []);
                         return {
                             outcome: { kind: 'unchanged', reason: 'already_compacted' },

package/node_modules/@maka/runtime/dist/conversation-copy.js

@@ -529,6 +529,12 @@ export async function cloneConversationRuntimeLedger(input) {
             await input.runStore.appendEvent(input.referenceMap.targetSessionId, runId, clonedEvent);
         }
         if (plan.terminal.kind === 'fact' && terminalEvent) {
+            // The preflight rejects handoff lineage before a plan reaches cloning,
+            // so a handed-off run never gets here; the guard keeps the outcome type
+            // honest at the boundary.
+            if (plan.terminal.fact.runStatus === 'handed_off') {
+                throw new Error(`Copied AgentRun ${plan.run.runId} carries unresolved handoff lineage`);
+            }
             await commitTerminalRunWithRuntimeFact({
                 runtimeEventStore: input.runtimeEventStore,
                 newId: input.newId,

package/node_modules/@maka/runtime/dist/runtime-event-read-model.js

@@ -567,6 +567,23 @@ export function classifyRuntimeEventTerminalFact(invocation, events) {
         return { diagnostics };
     }
     const terminalEvent = terminalSignals[0];
+    // A handoff pause seals the run without ending the turn: the successor run
+    // owns the turn's terminal state. The pause carries no terminal status by
+    // design — completed/failed/aborted would each be a lie about a run that was
+    // none of them — so it classifies as its own status. The event is immutable
+    // once written, so ledgers written before this classification carry exactly
+    // this shape.
+    if (terminalEvent.actions?.handoffPause) {
+        const fact = {
+            runId: invocation.runId,
+            turnId: invocation.turnId,
+            runStatus: 'handed_off',
+            turnStatus: 'handed_off',
+            terminalEvent,
+            diagnostics,
+        };
+        return { fact, diagnostics };
+    }
     if (!isTerminalRuntimeEventStatus(terminalEvent.status)) {
         diagnostics.push(readModelDiagnostic('incomplete_event', 'terminal RuntimeEvent requires a terminal status for recovery', terminalEvent));
         return { diagnostics };