newmark-agent 0.6.3 → 0.6.7

package/dist/conversation-utility-host.js

@@ -7,6 +7,8 @@ const conversationTarget_1 = require("./core/conversationTarget");
 const utilityHostToolBridge_1 = require("./core/utilityHostToolBridge");
 const terminalTakeover_1 = require("./tools/terminalTakeover");
 const runtimeLifecycle_1 = require("./core/runtimeLifecycle");
+const memoryProbe_1 = require("./core/memoryProbe");
+const workEventCoalescer_1 = require("./core/workEventCoalescer");
 const root = String(process.env.NEWMARK_RUNTIME_ROOT || '');
 const expectedRuntimeKey = String(process.env.NEWMARK_RUNTIME_KEY || '');
 if (!root)
@@ -17,6 +19,11 @@ const parentPort = process.parentPort;
 if (!parentPort)
     throw new Error('Electron utility parentPort is unavailable');
 const host = new agent_1.Agent(root, { runtimeLifecycleRole: 'utility' });
+/**
+ * Diagnostic probe (source-only, env-gated). `memoryProbe.disabled.ts` replaces
+ * this module in packaged builds, so no probe code ships in the final artifact.
+ */
+const hostHooks = (0, memoryProbe_1.installHostRuntimeHooks)({ root });
 host.tools.setHostProfile({
     kind: 'electron-utility',
     platform: process.platform,
@@ -26,9 +33,35 @@ host.tools.setHostProfile({
 const kernel = new conversationKernel_1.ConversationKernel(root, host, null);
 let activeTarget = null;
 function post(value) {
-    parentPort.postMessage(value);
+    hostHooks.countPosted(value);
+    try {
+        parentPort.postMessage(value);
+    }
+    catch { /* the parent may already be gone during shutdown */ }
+}
+/**
+ * dev-0.6.6 long-run stability: coalesce response/thought deltas **inside the
+ * host** before they cross the process boundary.
+ *
+ * Measured defect: the host posted one IPC message per model delta (18,746
+ * messages / 722 MiB for ~31 MB of model text — a 23x amplification) and the
+ * heap snapshot showed 10,728 retained per-delta strings. The main process
+ * already coalesces for the renderer (`main.ts` WorkEventCoalescer) and the
+ * renderer expands `coalescedDeltas` back into individual deltas, so batching at
+ * the host boundary changes nothing the user or the transcript sees — it only
+ * stops the per-delta pile-up. Lifecycle/tool events still flush immediately and
+ * keep their ordering.
+ */
+const hostWorkCoalescer = new workEventCoalescer_1.WorkEventCoalescer(event => post({ event: 'work', data: event }), Math.max(4, Number(process.env.NEWMARK_HOST_COALESCE_MS) || 16));
+function flushHostWorkEvents() {
+    try {
+        hostWorkCoalescer.flushAll();
+    }
+    catch { /* shutdown best effort */ }
 }
-kernel.subscribe(event => post({ event: 'work', data: event }));
+process.on('exit', flushHostWorkEvents);
+process.on('beforeExit', flushHostWorkEvents);
+kernel.subscribe(event => hostWorkCoalescer.push(event));
 function checkedTarget(target) {
     const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
     if (normalized.runtimeKey !== expectedRuntimeKey) {
@@ -37,6 +70,61 @@ function checkedTarget(target) {
     activeTarget = normalized;
     return normalized;
 }
+/**
+ * dev-0.6.6 long-run memory reclamation: the transcript part of a snapshot is
+ * only sent when the caller cannot already prove it holds that exact revision.
+ *
+ * Measured before this: RPC responses (mostly snapshots) were **86% of all
+ * cross-process bytes** in a 12-round load (24 responses = 329 MiB, single
+ * response up to 38 MB) because every poll re-serialized the whole conversation.
+ *
+ * The handshake is caller-driven: a slim payload is only produced when the
+ * caller supplies the revision it currently holds. A caller that holds nothing
+ * (or painted another conversation) receives the full transcript; the main
+ * process only attaches a revision it received from that same renderer through
+ * `conversation:ackTranscript`.
+ */
+const transcriptRevisions = new Map();
+function transcriptRevisionOf(snapshot) {
+    const messages = Array.isArray(snapshot.chatMessages) ? snapshot.chatMessages : [];
+    const runs = Array.isArray(snapshot.workRuns) ? snapshot.workRuns : [];
+    const last = messages.length ? messages[messages.length - 1] : null;
+    const lastRun = runs.length ? runs[runs.length - 1] : null;
+    // Only what the renderer actually paints takes part in the revision: the
+    // visible message window and the work-run summary. `history` deliberately
+    // does NOT: it grows on every tool round inside a turn, and folding it in made
+    // every mid-turn poll look "changed" (measured: no slim snapshots at all).
+    // Anything derived from `history` is only recomputed when the window changes,
+    // which is exactly when a full payload is sent anyway.
+    return [
+        messages.length,
+        String(last?.messageId || last?.clientMessageId || last?.timestamp || ''),
+        String(typeof last?.content === 'string' ? last.content.length : ''),
+        String(snapshot.totalMessages ?? ''),
+        String(snapshot.windowStart ?? ''),
+        runs.length,
+        String(lastRun?.status || ''),
+        String(lastRun?.endedAt || ''),
+    ].join('|');
+}
+function applyTranscriptPolicy(snapshot, options) {
+    const revision = transcriptRevisionOf(snapshot);
+    const key = `${snapshot.target?.workspaceId || ''}::${snapshot.target?.conversationId || ''}`;
+    transcriptRevisions.set(key, revision);
+    const callerRevision = String(options.transcriptRevision || '');
+    const full = options.transcript === 'force' || !callerRevision || callerRevision !== revision;
+    if (full)
+        return { ...snapshot, transcriptRevision: revision };
+    return {
+        ...snapshot,
+        chatMessages: undefined,
+        history: undefined,
+        workRuns: undefined,
+        workEvents: undefined,
+        transcriptUnchanged: true,
+        transcriptRevision: revision,
+    };
+}
 (0, utilityHostToolBridge_1.configureUtilityHostToolBridge)(request => post({ event: 'host_tool_request', data: request }), () => activeTarget ? {
     workspaceId: activeTarget.workspaceId,
     conversationId: activeTarget.conversationId,
@@ -64,8 +152,10 @@ async function handle(request) {
         const result = await kernel.prompt(request.params.message, target, request.params.options, request.params.queueMode);
         return { ...result, backend: 'utility', pid: process.pid };
     }
-    if (request.method === 'snapshot')
-        return kernel.snapshot(checkedTarget(request.params.target), request.params.options);
+    if (request.method === 'snapshot') {
+        const options = request.params.options || {};
+        return applyTranscriptPolicy(kernel.snapshot(checkedTarget(request.params.target), options), options);
+    }
     if (request.method === 'rewind') {
         return kernel.rewind(checkedTarget(request.params.target), request.params.messageIndex);
     }
@@ -87,9 +177,6 @@ async function handle(request) {
     if (request.method === 'context_compress') {
         return kernel.compressContext(checkedTarget(request.params.target), request.params.options);
     }
-    if (request.method === 'rate_auto_route') {
-        return kernel.rateAutoRoute(checkedTarget(request.params.target), request.params.score, request.params.routeId);
-    }
     if (request.method === 'set_work_run_expanded') {
         return kernel.setWorkRunExpanded(checkedTarget(request.params.target), request.params.runId, request.params.expanded);
     }

package/dist/core/agent.d.ts

@@ -55,11 +55,27 @@ export interface ModelValidationProgress {
         check: string;
     }>;
 }
-export interface AutoRouteRatingResult {
+/** Editable settings for model-backed Auto decisions. */
+export interface JevDecisionModelPatch {
+    enabled?: boolean;
+    timeoutMs?: number;
+}
+export interface JevDecisionModelState {
+    /** `models.auto_switch`: the user's Auto master switch. */
+    autoEnabled: boolean;
+    /** True when Auto is off: the decision model cannot be edited and cannot move a model. */
+    locked: boolean;
+    lockReason?: 'auto_disabled';
+    enabled: boolean;
+    decisionModel: 'current_eligible_model';
+    thinkingMode: 'off';
+    outputFormat: 'strict_json_schema';
+    timeoutMs: number;
+}
+export interface JevDecisionModelUpdateResult {
     ok: boolean;
-    score?: -1 | 1;
-    routeId?: string;
-    reason?: 'invalid_score' | 'no_active_auto_route' | 'stale_route' | 'already_rated';
+    reason?: 'auto_disabled' | 'invalid_value';
+    state: JevDecisionModelState;
 }
 export declare const ROOT_AGENT_ACTOR_ID = "00000000-0000-4000-8000-000000000001";
 export declare function normalizeIntelligenceTier(value: unknown): 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'ultra';
@@ -85,6 +101,8 @@ export interface CompressionCacheEntry {
     foldedChars: number;
     model: string;
     fallback: boolean;
+    /** Branch node that owns this folded history. Sibling pages must never read it. */
+    branchNodeId?: string;
 }
 type ConversationModelSelection = {
     kind: 'auto';
@@ -413,6 +431,8 @@ export declare class Agent {
     private modelSwitchCompressionPromise;
     private activePeerAgents;
     private peerProviderCaches;
+    /** Reuses the provider connection for current-model JEV calls without sharing conversation build state. */
+    private readonly jevProviderCache;
     private awaitingAgentKernelRuntime;
     private pendingAgentKernelQueue;
     private linkedPlanAccess;
@@ -432,7 +452,7 @@ export declare class Agent {
     private finalizingWorkRunId;
     private agentRunService;
     private agentRunByWorkRunId;
-    private readonly autoRouter;
+    private readonly routeController;
     private resolvedDeployment;
     private fixedDeployment;
     private preferredConversationModelSelection;
@@ -444,11 +464,21 @@ export declare class Agent {
     private lastRouteRetryDelayMs;
     private routeAttemptStartedAt;
     private readonly providerBalanceBlockedUntilByDeployment;
-    private readonly explicitlyRatedRoutes;
     private conversationStateCache;
     private conversationStateCacheFingerprint;
+    private conversationStateWrittenFingerprint;
+    private conversationShardFingerprint;
+    private hydratedShardEntries;
+    /**
+     * Revision of the durable queue snapshot this runtime is working from. The
+     * merge only accepts a writer's queue when that writer has seen the persisted
+     * revision, so an outdated in-memory snapshot can neither drop queued work
+     * nor resurrect an entry that was already consumed or cleared.
+     */
+    private continuationRevision;
     private conversationStateFlushTimers;
     private conversationStateDirty;
+    private conversationStateLastWriteAt;
     private systemPromptCache;
     private toolDefinitionCache;
     private modelValidationPromise;
@@ -528,6 +558,16 @@ export declare class Agent {
     activeModelName(): string;
     modelSelectionValue(): string;
     currentWorkRunId(): string;
+    /**
+     * The branch node that owns the currently active Build. Provider session ids
+     * and branch-scoped caches must use this identity instead of "the branch that
+     * happens to be active", otherwise a concurrently running sibling branch
+     * (branch-communication mode) or a page switched mid-Build would read another
+     * branch's remote session and folded history.
+     */
+    activeWorkRunBranchId(): string;
+    /** Full conversation identity of one branch node (shared by every branch kind). */
+    branchConversationIdentity(branchNodeId: string): string;
     activeModelConfig(): ReturnType<ConfigManager['allModels']>[number] | undefined;
     requestedModelSelection(): ModelSelection;
     resetAutoRoute(): void;
@@ -539,12 +579,65 @@ export declare class Agent {
     recordRouteSuccess(latencyMs?: number, throughput?: number): void;
     recordRouteToolOutcome(valid: boolean): void;
     updateProviders(value: unknown): void;
-    clearLearnedModelPreferences(): void;
-    rateActiveAutoRoute(score: number, expectedRouteId?: string): AutoRouteRatingResult;
-    recordObjectiveRouteResult(success: boolean): void;
-    private recordRouteQualityObservation;
+    /**
+     * Auto master switch. Every automatic model decision in this runtime is
+     * gated on it: when it is off the Agent neither routes nor edits the current
+     * model decision settings, and no code path may move the active model on its own.
+     */
+    autoDecisionEnabled(): boolean;
+    /** Current-model JEV settings exposed to GUI / TUI / CLI editors. */
+    jevDecisionModelState(): JevDecisionModelState;
+    /**
+     * Edit current-model Auto decision settings.
+     *
+     * Refuses every write while Auto is off (`auto_disabled`): with automatic
+     * decision-making disabled, not even the decision-model configuration may
+     * change — that is what "Auto off never moves a model" means at the editor
+     * boundary. Invalid values are rejected without touching the stored config.
+     */
+    updateJevDecisionModel(patch?: JevDecisionModelPatch): JevDecisionModelUpdateResult;
     private workspaceConversationKey;
     private workspaceConversationStorePath;
+    /**
+     * Heavy conversation payload that lives in a per-conversation shard file
+     * instead of the workspace index document. Everything else (title, pinning,
+     * order, draft, mode, goal, runtime owner, counters) stays in the index so
+     * listing, sorting and cross-process merge never need to parse a transcript.
+     */
+    private static readonly CONVERSATION_SHARD_FIELDS;
+    private workspaceConversationShardDir;
+    private conversationShardFileName;
+    private conversationShardPath;
+    /**
+     * Hydrate one conversation entry from its shard on first access. The heavy
+     * fields are non-enumerable so `{ ...entry }` (and therefore the index
+     * document written back to disk) never pulls a transcript into memory, while
+     * every existing reader that asks for `entry.chatMessages` / `entry.history`
+     * keeps working unchanged.
+     */
+    private attachConversationShard;
+    /**
+     * Heavy payload carried in memory by this entry, or `null` when the entry is
+     * a shard-backed index record whose heavy fields were never touched. That
+     * distinction is what keeps unrelated conversations off the write path.
+     */
+    private conversationShardSnapshot;
+    /**
+     * Force one shard-backed entry into memory. Used only on the rare recovery
+     * paths that must compare against a payload written by another runtime.
+     */
+    private hydrateConversationEntry;
+    /**
+     * Durable queue merge.
+     *
+     * Queue entries are the user's pending work, so a runtime that never saw an
+     * entry must not delete it, while an entry this runtime actually consumed
+     * must not be resurrected. Identity-based union minus exactly the consumed
+     * ids gives both guarantees without needing a global revision clock.
+     */
+    private mergeConversationContinuations;
+    /** Index-document form of a conversation entry: metadata plus a shard pointer. */
+    private conversationIndexEntryForDisk;
     private workspaceConversationStateKey;
     private workspaceConversationStateKeyFor;
     private workspaceConversationPrefix;
@@ -581,6 +674,16 @@ export declare class Agent {
     handleImageDisplayWithDescription(args: string, signal?: AbortSignal): Promise<string>;
     /** Keep media bytes in one content-addressed asset and state.json as refs. */
     private conversationEntryForDisk;
+    /**
+     * Bound the live Build ledger.
+     *
+     * `normalizeWorkRuns()` already windows the persisted/served ledger to 120
+     * runs, but the live `this.workRuns` array kept every Build block of the
+     * conversation (measured: 307 runs / 4.6 MiB after 300 turns). The renderer
+     * only ever shows the newest window, so older terminal runs can be dropped
+     * from memory while the conversation continues.
+     */
+    private pruneLiveWorkRuns;
     private normalizeWorkRuns;
     private recoverPersistedWorkRuns;
     private publishConversationTitle;
@@ -685,7 +788,20 @@ export declare class Agent {
     private normalizeContinuations;
     private normalizeConversationPlan;
     private readStoredConversationState;
+    /** Durable replacement-style text write (temp file + fsync + rename). */
+    private writeAtomicTextFile;
     private writeStoredConversationState;
+    /**
+     * Coalesced conversation-state write.
+     *
+     * Mid-turn persistence used to rewrite the whole workspace document
+     * synchronously on every kernel event (measured: 5.33 full rewrites per turn
+     * with no tools). The document grows with the conversation, so that cost grew
+     * with the turn count. This path keeps durability at turn boundaries (the
+     * terminal save stays synchronous and cancels any pending timer) while
+     * throttling intermediate saves: the latest snapshot wins, and bursts inside
+     * one throttle window collapse into a single write.
+     */
     private scheduleStoredConversationState;
     flushWorkspaceConversationState(): void;
     getStoredFlowSuspension(conversationId?: string, ws?: WorkspaceInfo | null): FlowSuspensionRecord | null;
@@ -1105,10 +1221,20 @@ export declare class Agent {
     private autoSwitchSubset;
     private autoRouteCandidates;
     private persistRouteDecision;
-    private loadLearnedRouteFeedback;
-    private recordRouteFeedbackFor;
     allModelNames(): string[];
     evaluateAndSwitch(task: string, override?: AgentPromptMessage['routePolicy']): Promise<boolean>;
+    /**
+     * Auto Router v2 decision pipeline:
+     *
+     *   RouteEligibilityGuard → JevDecisionEngine → RouteDecisionValidator → pin
+     *
+     * The current conversation model is the only Auto decision source. If it is
+     * disabled, times out, crashes or returns something the guard cannot accept,
+     * Auto stops without selecting another deployment.
+     */
+    private decideAutoRoute;
+    /** Resolve JEV to the current eligible conversation model, never a second model slot. */
+    private resolveCurrentModelJevEngine;
     shouldExposeToolInterface(): boolean;
     modelIsUnavailable(modelName: string): boolean;
     private failedDeploymentsThisRun;
@@ -1229,6 +1355,17 @@ export declare class Agent {
     private formatCompressionSummary;
     private persistCompressedHistory;
     private compressionArchiveScopeKey;
+    /**
+     * The hot folded-history cache belongs to one branch node. Legacy entries
+     * (created before branch scoping) belong to the root node, which is where
+     * they were produced.
+     */
+    private compressionCacheForBranch;
+    /**
+     * Persist the union of every branch's folded history: the live in-memory
+     * cache only holds the active branch, and the stored entry holds the rest.
+     */
+    private mergedCompressionCacheForPersist;
     private coldCompressionEntries;
     private compressionArchiveEntryCount;
     private archiveColdCompressionEntries;