@kenkaiiii/ggcoder 5.29.1 → 5.30.0

package/dist/core/agent-session.js

@@ -11,8 +11,9 @@ import { getClaudeCliUserAgent } from "./claude-code-version.js";
 import { kimiCodingHeaders, isKimiCodingEndpoint } from "./oauth/kimi.js";
 import { SessionManager, KEN_TURN_CUSTOM_KIND, AUTOPILOT_MARKER_CUSTOM_KIND, APP_MARKER_CUSTOM_KIND, } from "./session-manager.js";
 import { ExtensionLoader } from "./extensions/loader.js";
-import { shouldCompact, compact } from "./compaction/compactor.js";
+import { shouldCompact, compact, } from "./compaction/compactor.js";
 import { remapAnchorForCompaction, stripRecordedPosition } from "./session-history.js";
+import { sourceFingerprint as computeSourceFingerprint } from "./session-compaction.js";
 import { getAuthStorageKeys, getContextWindow, getModel, getToolResultCharLimit, MODELS, } from "./model-registry.js";
 import { discoverSkills } from "./skills.js";
 import { ensureAppDirs } from "../config.js";
@@ -30,6 +31,7 @@ import { createToolSearchTool } from "../tools/tool-search.js";
 import { log } from "./logger.js";
 import { setEstimatorModel, calibrateEstimatorFromUsage } from "./compaction/token-estimator.js";
 import { calculateActiveContextTokens } from "./compaction/active-context.js";
+import { resolveCompactionPolicy } from "./compaction/policy.js";
 import { pruneStaleToolResults } from "./compaction/tool-result-pruner.js";
 import { discoverAgents } from "./agents.js";
 import { enhancePrompt } from "../utils/prompt-enhancer.js";
@@ -149,6 +151,8 @@ export class AgentSession {
     compactionOccurred = false;
     lastCompactionCompacted = false;
     compactionRetryAfter = 0;
+    /** A restored oversized checkpoint must be canonicalized before its first prompt is persisted. */
+    deferredCompactionPending = false;
     /** Latest provider count, anchored to the assistant response it measured. */
     providerContext = null;
     originalRequest = "";
@@ -206,6 +210,7 @@ export class AgentSession {
     /** Extra workspace roots added with `/add-dir` (resolved, de-duplicated). */
     additionalRoots = [];
     sessionId = "";
+    checkpointGeneration = 0;
     /** Stable identity shared by compaction and approved-plan checkpoint files. */
     conversationId = "";
     /** Original user-authored prompt, retained when internal messages replace history. */
@@ -753,12 +758,16 @@ export class AgentSession {
     /**
      * Process user input. Handles slash commands or runs agent loop.
      */
-    async prompt(content) {
+    async prompt(content, provenance = {
+        source: "human",
+        kind: "prompt",
+        visibility: "transcript",
+    }) {
+        await this.adoptDeferredCheckpointBeforePrompt();
         const slash = await this.resolveSlashInput(content);
         if (slash?.kind === "template") {
-            // Inject the prompt-template command as a user message to the agent, then
-            // run as a normal prompt (push message + agent loop).
-            const userMessage = { role: "user", content: slash.fullPrompt };
+            // Prompt templates remain human-originated: the user invoked the command.
+            const userMessage = { role: "user", content: slash.fullPrompt, provenance };
             this.messages.push(userMessage);
             await this.persistMessage(userMessage);
             this.lastPersistedIndex = this.messages.length;
@@ -774,7 +783,7 @@ export class AgentSession {
             return;
         }
         // Push user message
-        const userMessage = { role: "user", content };
+        const userMessage = { role: "user", content, provenance };
         this.messages.push(userMessage);
         await this.persistMessage(userMessage);
         this.lastPersistedIndex = this.messages.length;
@@ -788,10 +797,15 @@ export class AgentSession {
      * attachments are always a direct conversational turn.
      */
     async promptWithAttachments(text, attachments) {
+        await this.adoptDeferredCheckpointBeforePrompt();
         const parts = this.buildAttachmentParts(text, attachments);
         if (parts.length === 0)
             return;
-        const userMessage = { role: "user", content: parts };
+        const userMessage = {
+            role: "user",
+            content: parts,
+            provenance: { source: "human", kind: "prompt", visibility: "transcript" },
+        };
         this.messages.push(userMessage);
         await this.persistMessage(userMessage);
         this.lastPersistedIndex = this.messages.length;
@@ -993,6 +1007,7 @@ export class AgentSession {
             ? {
                 role: "user",
                 content: buildNotificationSteeringText(notified.map((entry) => entry.text)),
+                provenance: { source: "runtime", kind: "notification", visibility: "hidden" },
             }
             : null;
         if (notificationMessage) {
@@ -1016,8 +1031,13 @@ export class AgentSession {
             // (not merged): each persists as its own user message, so a resumed
             // session shows the same number of bubbles the live run did.
             const steeringMessages = queued.map((m) => {
+                const provenance = {
+                    source: "human",
+                    kind: "steering",
+                    visibility: "transcript",
+                };
                 if (m.attachments.length === 0) {
-                    return { role: "user", content: wrapSteeringText(m.text) };
+                    return { role: "user", content: wrapSteeringText(m.text), provenance };
                 }
                 // Queued attachments ride the same native-block path as a non-queued
                 // attachment prompt, prefixed with the steering framing.
@@ -1025,7 +1045,7 @@ export class AgentSession {
                     { type: "text", text: STEERING_PREFIX },
                     ...this.buildAttachmentParts(m.text, m.attachments),
                 ];
-                return { role: "user", content: parts };
+                return { role: "user", content: parts, provenance };
             });
             return notificationMessage ? [...steeringMessages, notificationMessage] : steeringMessages;
         }
@@ -1207,7 +1227,11 @@ export class AgentSession {
                 : []),
             "Do not describe those files as compiler-clean without other evidence.",
         ];
-        return { role: "user", content: `${String(message.content)}\n\n${notes.join(" ")}` };
+        return {
+            role: "user",
+            provenance: message.provenance,
+            content: `${String(message.content)}\n\n${notes.join(" ")}`,
+        };
     }
     /** Auto-compact if needed, run agent loop with auth retry, and persist messages. */
     async runLoop() {
@@ -1247,7 +1271,14 @@ export class AgentSession {
                 provider: this.provider,
                 accountId: creds.accountId,
             });
-            const threshold = this.settingsManager.get("compactThreshold");
+            const policy = resolveCompactionPolicy({
+                provider: this.provider,
+                model: this.model,
+                contextWindow,
+                threshold: this.settingsManager.get("compactThreshold"),
+                accountId: creds.accountId,
+                approvedPlanPath: this.approvedPlanPath,
+            });
             let activeTokens;
             if (this.providerContext) {
                 const anchorIndex = this.messages.lastIndexOf(this.providerContext.anchor);
@@ -1261,9 +1292,17 @@ export class AgentSession {
                     this.providerContext = null;
                 }
             }
-            if (shouldCompact(this.messages, contextWindow, threshold, activeTokens)) {
+            log("INFO", "compaction", "Pre-run compaction decision", {
+                provider: this.provider,
+                model: this.model,
+                transport: this.provider === "openai" && creds.accountId ? "codex_oauth" : "public_api",
+                contextWindow: String(contextWindow),
+                activeTokens: activeTokens === undefined ? "estimated" : String(activeTokens),
+                triggerLimit: String(policy.targetTokens),
+            });
+            if (shouldCompact(this.messages, contextWindow, policy.threshold, activeTokens)) {
                 try {
-                    await this.compact(creds);
+                    await this.compact(creds, "automatic");
                     if (this.lastCompactionCompacted) {
                         // Re-grounding hook keys off this — the context was just summarized.
                         this.compactionOccurred = true;
@@ -1373,12 +1412,27 @@ export class AgentSession {
                             provider: this.provider,
                             accountId,
                         });
-                        const threshold = this.settingsManager.get("compactThreshold");
+                        const policy = resolveCompactionPolicy({
+                            provider: this.provider,
+                            model: this.model,
+                            contextWindow,
+                            threshold: this.settingsManager.get("compactThreshold"),
+                            accountId,
+                            approvedPlanPath: this.approvedPlanPath,
+                        });
                         const activeTokens = calculateActiveContextTokens(messages, {
                             usage,
                             pendingMessages,
                         });
-                        if (!shouldCompact(messages, contextWindow, threshold, activeTokens))
+                        log("INFO", "compaction", "In-flight compaction decision", {
+                            provider: this.provider,
+                            model: this.model,
+                            transport: this.provider === "openai" && accountId ? "codex_oauth" : "public_api",
+                            contextWindow: String(contextWindow),
+                            activeTokens: String(activeTokens),
+                            triggerLimit: String(policy.targetTokens),
+                        });
+                        if (!shouldCompact(messages, contextWindow, policy.threshold, activeTokens))
                             return messages;
                     }
                     // compact() operates on this.messages, while an earlier transform may
@@ -1391,7 +1445,7 @@ export class AgentSession {
                             accountId,
                             projectId,
                             baseUrl: effectiveBaseUrl,
-                        });
+                        }, force ? "forced" : "automatic");
                     }
                     catch (error) {
                         this.messages = messages;
@@ -1640,9 +1694,66 @@ export class AgentSession {
         this.messages.push({
             role: "user",
             content: `[Model switched from ${from} to ${to}. Everything above was produced under the previous model; continue the current task from here.]`,
+            provenance: { source: "runtime", kind: "model_switch", visibility: "hidden" },
         });
     }
-    async compact(existingCredentials) {
+    async adoptCompactionCheckpoint(loaded) {
+        const systemMessage = this.messages[0];
+        const loadedMessages = this.sessionManager.getMessages(loaded.entries, loaded.header.leafId);
+        this.messages = [systemMessage, ...loadedMessages];
+        this.sessionId = loaded.header.id;
+        this.conversationId = loaded.header.conversationId ?? loaded.header.id;
+        this.checkpointGeneration = loaded.header.generation ?? 0;
+        this.currentLeafId = loaded.header.leafId;
+        this.setSessionPath(loaded.path);
+        this.kenTurns = this.sessionManager.getKenTurns(loaded.entries, loaded.header.leafId);
+        this.autopilotMarkers = this.sessionManager.getAutopilotMarkers(loaded.entries, loaded.header.leafId);
+        this.appMarkers = this.sessionManager.getAppMarkers(loaded.entries, loaded.header.leafId);
+        this.turnMetrics = this.sessionManager.getTurnMetrics(loaded.entries);
+        this.lastPersistedIndex = this.messages.length;
+        this.providerContext = null;
+        await this.subAgentManager?.rebindParentSession(this.sessionId);
+    }
+    /** Canonicalize a deferred restore before a new prompt can fork stale history. */
+    async adoptDeferredCheckpointBeforePrompt() {
+        if (!this.deferredCompactionPending || !this.conversationId)
+            return;
+        this.deferredCompactionPending = false;
+        const canonicalPath = await this.sessionManager.resolveCanonicalSession(this.conversationId, this.cwd);
+        if (!canonicalPath || canonicalPath === this.sessionPath)
+            return;
+        await this.adoptCompactionCheckpoint(await this.sessionManager.load(canonicalPath));
+    }
+    async persistCompactionCheckpoint(sourceFingerprint, result) {
+        const parentSessionId = this.sessionId || undefined;
+        const session = await this.sessionManager.create(this.cwd, this.provider, this.model, {
+            conversationId: this.conversationId || undefined,
+            generation: this.checkpointGeneration + 1,
+            parentSessionId,
+            sourceFingerprint,
+            preview: this.sessionPreview || undefined,
+        });
+        this.sessionId = session.id;
+        this.checkpointGeneration = session.header.generation ?? 0;
+        this.conversationId = session.header.conversationId ?? session.id;
+        this.currentLeafId = null;
+        this.setSessionPath(session.path);
+        await this.subAgentManager?.rebindParentSession(this.sessionId);
+        for (const message of this.messages) {
+            if (message.role !== "system")
+                await this.persistMessage(message);
+        }
+        this.lastPersistedIndex = this.messages.length;
+        await this.rePersistTurnMetrics();
+        await this.rePersistKenTurns();
+        await this.rePersistAutopilotMarkers();
+        await this.rePersistAppMarkers();
+        await this.persistAppMarker("compaction", {
+            originalCount: result.originalCount,
+            newCount: result.newCount,
+        });
+    }
+    async compact(existingCredentials, mode = "manual") {
         this.lastCompactionCompacted = false;
         const creds = existingCredentials ??
             (await this.authStorage.resolveCredentials(this.provider, {
@@ -1652,8 +1763,17 @@ export class AgentSession {
             provider: this.provider,
             accountId: creds.accountId,
         });
-        this.eventBus.emit("compaction_start", { messageCount: this.messages.length });
-        const result = await compact(this.messages, {
+        const policy = resolveCompactionPolicy({
+            provider: this.provider,
+            model: this.model,
+            contextWindow,
+            threshold: this.settingsManager.get("compactThreshold"),
+            accountId: creds.accountId,
+            approvedPlanPath: this.approvedPlanPath,
+        });
+        const originalCount = this.messages.length;
+        this.eventBus.emit("compaction_start", { messageCount: originalCount });
+        const runCompactor = () => compact(this.messages, {
             provider: this.provider,
             model: this.model,
             apiKey: creds.accessToken,
@@ -1661,67 +1781,106 @@ export class AgentSession {
             projectId: creds.projectId,
             baseUrl: this.baseUrl ?? creds.baseUrl,
             contextWindow,
+            targetTokens: policy.targetTokens,
             signal: this.opts.signal,
+            approvedPlanPath: this.approvedPlanPath,
         });
-        this.messages = result.messages;
-        this.lastCompactionCompacted = result.result.compacted;
-        if (!result.result.compacted) {
-            this.eventBus.emit("compaction_end", {
-                compacted: false,
-                originalCount: result.result.originalCount,
-                newCount: result.result.newCount,
-            });
-            return;
-        }
-        this.providerContext = null;
-        // Compaction rewrote the message list, so every transcript anchor recorded
-        // against the old indices must move with it — otherwise the markers are
-        // re-persisted pointing at positions that no longer mean anything and
-        // replay far below where they happened (or past the end).
-        this.remapMarkerAnchors(result.result.anchorRemap);
-        // Transient sessions (Ken chat/autopilot, subagent spawns) must NEVER touch
-        // the session store: without this guard, the first auto-compaction called
-        // sessionManager.create() and assigned a real sessionPath, silently turning
-        // the "in-memory only" session into a persisted one — every later turn (and
-        // every further compaction) then leaked a Ken transcript file into the
-        // project's session list. Compact in memory only and keep sessionPath empty.
-        if (this.opts.transient) {
-            this.lastPersistedIndex = this.messages.length;
+        let finalCount = originalCount;
+        if (this.opts.transient || !this.conversationId) {
+            const result = await runCompactor();
+            finalCount = result.result.newCount;
+            this.messages = result.messages;
+            this.lastCompactionCompacted = result.result.compacted;
+            if (result.result.compacted) {
+                this.providerContext = null;
+                this.remapMarkerAnchors(result.result.anchorRemap);
+                this.lastPersistedIndex = this.messages.length;
+            }
         }
         else {
-            // Persist compacted messages to a new session file so `ggcoder continue`
-            // picks up the compacted state instead of the full original history.
-            const session = await this.sessionManager.create(this.cwd, this.provider, this.model, {
-                conversationId: this.conversationId || undefined,
-                preview: this.sessionPreview || undefined,
-            });
-            this.sessionId = session.id;
-            this.conversationId = session.header.conversationId ?? session.id;
-            this.setSessionPath(session.path);
-            await this.subAgentManager?.rebindParentSession(this.sessionId);
-            // Write compacted messages (skip system — it's rebuilt on load)
-            for (const msg of this.messages) {
-                if (msg.role === "system")
-                    continue;
-                await this.persistMessage(msg);
-            }
-            this.lastPersistedIndex = this.messages.length;
-            // Carry evidence records into the new file so they survive compaction.
-            await this.rePersistTurnMetrics();
-            await this.rePersistKenTurns();
-            await this.rePersistAutopilotMarkers();
-            await this.rePersistAppMarkers();
-            // Persist the compaction counts so a resumed session's quiet notice can
-            // show the same "N → M messages" summary the live run did.
-            await this.persistAppMarker("compaction", {
-                originalCount: result.result.originalCount,
-                newCount: result.result.newCount,
+            const conversationId = this.conversationId;
+            await this.sessionManager.withCompactionLease(conversationId, this.opts.signal, async () => {
+                let sourceFingerprint = computeSourceFingerprint(this.messages);
+                const canonicalPath = await this.sessionManager.resolveCanonicalSession(conversationId, this.cwd);
+                if (canonicalPath && canonicalPath !== this.sessionPath) {
+                    const newest = await this.sessionManager.load(canonicalPath);
+                    if (newest.header.sourceFingerprint === sourceFingerprint) {
+                        await this.adoptCompactionCheckpoint(newest);
+                        this.lastCompactionCompacted = true;
+                        finalCount = this.messages.length;
+                        return;
+                    }
+                    // The canonical branch contains different progress. Rebase onto it before
+                    // compacting so a stale caller cannot supersede newer history by generation.
+                    await this.adoptCompactionCheckpoint(newest);
+                    sourceFingerprint = computeSourceFingerprint(this.messages);
+                }
+                const attempt = await this.sessionManager.readCompactionAttemptState(conversationId);
+                const attemptActive = !attempt?.expiresAt || Date.parse(attempt.expiresAt) > Date.now();
+                if (mode === "automatic" &&
+                    attempt?.fingerprint === sourceFingerprint &&
+                    attempt.policyKey === policy.policyKey &&
+                    attemptActive) {
+                    if (attempt.outcome === "success" && attempt.checkpointId) {
+                        const checkpointPath = await this.sessionManager.findById(this.cwd, attempt.checkpointId);
+                        if (checkpointPath) {
+                            const checkpoint = await this.sessionManager.load(checkpointPath);
+                            if (checkpoint.header.sourceFingerprint === sourceFingerprint) {
+                                await this.adoptCompactionCheckpoint(checkpoint);
+                                this.lastCompactionCompacted = true;
+                                finalCount = this.messages.length;
+                                return;
+                            }
+                        }
+                    }
+                    else if (attempt.outcome === "failed" || attempt.outcome === "noop") {
+                        return;
+                    }
+                }
+                try {
+                    const result = await runCompactor();
+                    finalCount = result.result.newCount;
+                    this.messages = result.messages;
+                    this.lastCompactionCompacted = result.result.compacted;
+                    if (!result.result.compacted) {
+                        await this.sessionManager.writeCompactionAttemptState(conversationId, {
+                            fingerprint: sourceFingerprint,
+                            policyKey: policy.policyKey,
+                            outcome: "noop",
+                            updatedAt: new Date().toISOString(),
+                            expiresAt: new Date(Date.now() + 30_000).toISOString(),
+                        });
+                        return;
+                    }
+                    this.providerContext = null;
+                    this.remapMarkerAnchors(result.result.anchorRemap);
+                    await this.persistCompactionCheckpoint(sourceFingerprint, result.result);
+                    await this.sessionManager.writeCompactionAttemptState(conversationId, {
+                        fingerprint: sourceFingerprint,
+                        policyKey: policy.policyKey,
+                        outcome: "success",
+                        checkpointId: this.sessionId,
+                        updatedAt: new Date().toISOString(),
+                    });
+                }
+                catch (error) {
+                    await this.sessionManager
+                        .writeCompactionAttemptState(conversationId, {
+                        fingerprint: sourceFingerprint,
+                        policyKey: policy.policyKey,
+                        outcome: "failed",
+                        updatedAt: new Date().toISOString(),
+                        expiresAt: new Date(Date.now() + 30_000).toISOString(),
+                    })
+                        .catch(() => { });
+                    throw error;
+                }
             });
         }
         this.eventBus.emit("compaction_end", {
-            compacted: true,
-            originalCount: result.result.originalCount,
-            newCount: result.result.newCount,
+            compacted: this.lastCompactionCompacted,
+            originalCount,
+            newCount: finalCount,
         });
     }
     async newSession(preserveConversation = false) {
@@ -1729,6 +1888,7 @@ export class AgentSession {
         // explicit new sessions reset the conversation identity.
         if (!preserveConversation) {
             this.conversationId = "";
+            this.checkpointGeneration = 0;
             this.sessionPreview = "";
         }
         // A fresh session drops any in-flight plan state so its prompt is clean.
@@ -1756,6 +1916,7 @@ export class AgentSession {
         if (this.opts.transient) {
             this.sessionId = "";
             this.conversationId = "";
+            this.checkpointGeneration = 0;
             this.sessionPreview = "";
             this.setSessionPath("");
             this.lastPersistedIndex = this.messages.length;
@@ -2400,19 +2561,28 @@ export class AgentSession {
             this.sessionManager.registerActivePath(nextPath);
     }
     async createNewSession() {
+        const continuingConversation = Boolean(this.conversationId && this.sessionId);
         const session = await this.sessionManager.create(this.cwd, this.provider, this.model, {
             conversationId: this.conversationId || undefined,
+            generation: continuingConversation ? this.checkpointGeneration + 1 : 0,
+            parentSessionId: continuingConversation ? this.sessionId : undefined,
             preview: this.sessionPreview || undefined,
         });
         this.sessionId = session.id;
+        this.checkpointGeneration = session.header.generation ?? 0;
         this.conversationId = session.header.conversationId ?? session.id;
         this.setSessionPath(session.path);
         this.lastPersistedIndex = this.messages.length;
     }
     async loadExistingSession(sessionPath) {
-        const loaded = await this.sessionManager.load(sessionPath);
+        // A stale physical checkpoint is only an address, not the conversation tip.
+        // Resolve every resume—not just over-threshold/deferred compaction resumes—
+        // before reading history so the next prompt cannot continue an old branch.
+        const canonicalPath = (await this.sessionManager.resolveCanonicalSession(sessionPath, this.cwd)) ?? sessionPath;
+        const loaded = await this.sessionManager.load(canonicalPath);
         // Use the leaf from the header to walk the correct branch
         const loadedMessages = this.sessionManager.getMessages(loaded.entries, loaded.header.leafId);
+        this.checkpointGeneration = loaded.header.generation ?? 0;
         this.conversationId = loaded.header.conversationId ?? loaded.header.id;
         const legacyLabel = [...loaded.entries]
             .reverse()
@@ -2461,67 +2631,41 @@ export class AgentSession {
             provider: this.provider,
             accountId: creds.accountId,
         });
+        this.sessionId = loaded.header.id;
+        this.setSessionPath(loaded.path);
+        this.lastPersistedIndex = this.messages.length;
+        const loadPolicy = resolveCompactionPolicy({
+            provider: this.provider,
+            model: this.model,
+            contextWindow,
+            threshold: this.settingsManager.get("compactThreshold"),
+            accountId: creds.accountId,
+            approvedPlanPath: this.approvedPlanPath,
+        });
+        log("INFO", "compaction", "Restore compaction decision", {
+            provider: this.provider,
+            model: this.model,
+            transport: this.provider === "openai" && creds.accountId ? "codex_oauth" : "public_api",
+            contextWindow: String(contextWindow),
+            activeTokens: "estimated",
+            triggerLimit: String(loadPolicy.targetTokens),
+        });
         const needsLoadCompaction = this.settingsManager.get("autoCompact") &&
-            shouldCompact(this.messages, contextWindow, this.settingsManager.get("compactThreshold"));
+            shouldCompact(this.messages, contextWindow, loadPolicy.threshold);
         if (needsLoadCompaction && this.opts.deferLoadCompaction) {
-            // Host readiness is gated on initialize() — don't block it on a summary
-            // LLM call (up to 30s). runLoop()'s pre-run auto-compaction picks this
-            // up on the first prompt and emits compaction_start/_end for the UI.
+            // Canonicalize again immediately before the first prompt is persisted:
+            // another process may create the shared checkpoint after this load.
+            this.deferredCompactionPending = true;
             log("INFO", "session", "Restored session exceeds context — deferring compaction to first prompt");
         }
         else if (needsLoadCompaction) {
             await this.subAgentManager?.hydrate(loaded.header.id);
             log("INFO", "session", `Restored session exceeds context — auto-compacting`);
-            const compacted = await compact(this.messages, {
-                provider: this.provider,
-                model: this.model,
-                apiKey: creds.accessToken,
-                accountId: creds.accountId,
-                projectId: creds.projectId,
-                baseUrl: this.baseUrl ?? creds.baseUrl,
-                contextWindow,
-                signal: this.opts.signal,
-            });
-            this.messages = compacted.messages;
-            // Same anchor rebase as compact(): the restored markers were recorded
-            // against the pre-compaction transcript.
-            this.remapMarkerAnchors(compacted.result.anchorRemap);
-            log("INFO", "session", `Auto-compaction complete`, {
-                before: String(compacted.result.originalCount),
-                after: String(compacted.result.newCount),
-            });
-            // Compaction rewrote history, so the on-disk file no longer reflects
-            // what's in memory — fork a fresh session file for the compacted state
-            // (mirrors compact()'s own persistence) so `ggcoder continue` picks up
-            // the summary instead of the full original transcript.
-            const session = await this.sessionManager.create(this.cwd, this.provider, this.model, {
-                conversationId: this.conversationId || undefined,
-                preview: this.sessionPreview || undefined,
-            });
-            this.sessionId = session.id;
-            this.conversationId = session.header.conversationId ?? session.id;
-            this.setSessionPath(session.path);
-            await this.subAgentManager?.rebindParentSession(this.sessionId);
-            this.currentLeafId = null;
-            // Re-persist (compacted) messages — skip system, it's rebuilt on load
-            for (const msg of this.messages) {
-                if (msg.role === "system")
-                    continue;
-                await this.persistMessage(msg);
+            await this.compact(creds, "automatic");
+            if (this.lastCompactionCompacted) {
+                await this.recordInterruptedRuns(interruptedRuns);
+                return;
             }
-            this.lastPersistedIndex = this.messages.length;
-            // Carry restored evidence into the continuation file.
-            await this.rePersistTurnMetrics();
-            await this.rePersistKenTurns();
-            await this.rePersistAutopilotMarkers();
-            await this.rePersistAppMarkers();
-            // Record this load-time auto-compaction's counts for the resumed notice.
-            await this.persistAppMarker("compaction", {
-                originalCount: compacted.result.originalCount,
-                newCount: compacted.result.newCount,
-            });
-            await this.recordInterruptedRuns(interruptedRuns);
-            return;
         }
         // Plain resume (no compaction needed): keep using the original session
         // file/id and append future turns to it in place. Forking a new file here
@@ -2560,8 +2704,10 @@ export class AgentSession {
         return this.messages;
     }
     async persistMessage(message) {
-        if (!this.sessionPreview && message.role === "user") {
-            this.sessionPreview = getUserSessionPrompt(message.content) ?? "";
+        if (!this.sessionPreview &&
+            message.role === "user" &&
+            (message.provenance?.source === "human" || !message.provenance)) {
+            this.sessionPreview = getUserSessionPrompt(message.content, message.provenance) ?? "";
         }
         // Transient sessions (subagent spawns) have no session file — skip.
         if (!this.sessionPath)
@@ -2581,7 +2727,7 @@ export class AgentSession {
     createSlashCommandContext() {
         return {
             switchModel: (provider, model) => this.switchModel(provider, model),
-            compact: () => this.compact(),
+            compact: () => this.compact(undefined, "manual"),
             newSession: () => this.newSession(),
             listSessions: async () => {
                 const sessions = await this.sessionManager.list(this.cwd);