diff --git a/lib/commands/sweep.ts b/lib/commands/sweep.ts
index 394c91b7..4e0ce331 100644
--- a/lib/commands/sweep.ts
+++ b/lib/commands/sweep.ts
@@ -15,7 +15,7 @@ import { formatPrunedItemsList } from "../ui/utils"
 import { getCurrentParams, getTotalToolTokens } from "../strategies/utils"
 import { buildToolIdList, isIgnoredUserMessage } from "../messages/utils"
 import { saveSessionState } from "../state/persistence"
-import { isMessageCompacted } from "../shared-utils"
+import { getLastUserMessage, isMessageCompacted } from "../shared-utils"
 import { getFilePathsFromParameters, isProtected } from "../protected-file-patterns"
 import { syncToolCache } from "../state/tool-cache"
 
@@ -215,11 +215,21 @@ export async function handleSweepCommand(ctx: SweepCommandContext): Promise<void
     }
 
     const tokensSaved = getTotalToolTokens(state, newToolIds)
+    const originMessageId = getLastUserMessage(messages)?.info.id || ""
+    if (!originMessageId) {
+        logger.warn("Sweep prune origin unavailable - missing user message")
+    }
 
     // Add to prune list
     for (const id of newToolIds) {
         const entry = state.toolParameters.get(id)
         state.prune.tools.set(id, entry?.tokenCount ?? 0)
+        if (originMessageId) {
+            state.prune.origins.set(id, {
+                source: "sweep",
+                originMessageId,
+            })
+        }
     }
     state.stats.pruneTokenCounter += tokensSaved
     state.stats.totalPruneTokens += state.stats.pruneTokenCounter
diff --git a/lib/config.ts b/lib/config.ts
index 1ea6c0d8..221c16d5 100644
--- a/lib/config.ts
+++ b/lib/config.ts
@@ -90,6 +90,8 @@ const DEFAULT_PROTECTED_TOOLS = [
     "batch",
     "plan_enter",
     "plan_exit",
+    "write",
+    "edit",
 ]
 
 // Valid config keys for validation against user config
diff --git a/lib/hooks.ts b/lib/hooks.ts
index 5a16f541..ddb87b32 100644
--- a/lib/hooks.ts
+++ b/lib/hooks.ts
@@ -4,7 +4,7 @@ import type { PluginConfig } from "./config"
 import { assignMessageRefs } from "./message-ids"
 import { syncToolCache } from "./state/tool-cache"
 import { deduplicate, supersedeWrites, purgeErrors } from "./strategies"
-import { prune, insertPruneToolContext, insertMessageIdContext } from "./messages"
+import { prune, syncToolOrigins, insertPruneToolContext, insertMessageIdContext } from "./messages"
 import { buildToolIdList, isIgnoredUserMessage } from "./messages/utils"
 import { checkSession } from "./state"
 import { renderSystemPrompt } from "./prompts"
@@ -113,6 +113,7 @@ export function createChatMessageTransformHandler(
 
         syncToolCache(state, config, logger, output.messages)
         buildToolIdList(state, output.messages, logger)
+        syncToolOrigins(state, logger, output.messages)
 
         deduplicate(state, logger, config, output.messages)
         supersedeWrites(state, logger, config, output.messages)
diff --git a/lib/messages/index.ts b/lib/messages/index.ts
index 78efa7b0..0b989be0 100644
--- a/lib/messages/index.ts
+++ b/lib/messages/index.ts
@@ -1,3 +1,4 @@
 export { prune } from "./prune"
+export { syncToolOrigins } from "./sync"
 export { insertPruneToolContext } from "./inject"
 export { insertMessageIdContext } from "./inject"
diff --git a/lib/messages/prune.ts b/lib/messages/prune.ts
index 9d317f4e..8029d704 100644
--- a/lib/messages/prune.ts
+++ b/lib/messages/prune.ts
@@ -108,13 +108,14 @@ const pruneToolInputs = (state: SessionState, logger: Logger, messages: WithPart
             if (part.type !== "tool") {
                 continue
             }
-            if (part.tool === "compress" && part.state.status === "completed") {
-                const content = part.state.input?.content
-                if (content && typeof content === "object" && "summary" in content) {
-                    content.summary = PRUNED_COMPRESS_SUMMARY_REPLACEMENT
-                }
-                continue
-            }
+
+            // if (part.tool === "compress" && part.state.status === "completed") {
+            //     const content = part.state.input?.content
+            //     if (content && typeof content === "object" && "summary" in content) {
+            //         content.summary = PRUNED_COMPRESS_SUMMARY_REPLACEMENT
+            //     }
+            //     continue
+            // }
 
             if (!state.prune.tools.has(part.callID)) {
                 continue
diff --git a/lib/messages/sync.ts b/lib/messages/sync.ts
new file mode 100644
index 00000000..f9d0c1c8
--- /dev/null
+++ b/lib/messages/sync.ts
@@ -0,0 +1,39 @@
+import type { SessionState, WithParts } from "../state"
+import type { Logger } from "../logger"
+
+export const syncToolOrigins = (
+    state: SessionState,
+    logger: Logger,
+    messages: WithParts[],
+): void => {
+    if (!state.prune.origins?.size) {
+        return
+    }
+
+    const messageIds = new Set(messages.map((msg) => msg.info.id))
+    let removedToolCount = 0
+    let removedOriginCount = 0
+
+    for (const [toolId, origin] of state.prune.origins.entries()) {
+        if (!state.prune.tools.has(toolId)) {
+            state.prune.origins.delete(toolId)
+            removedOriginCount++
+            continue
+        }
+
+        if (!messageIds.has(origin.originMessageId)) {
+            state.prune.origins.delete(toolId)
+            removedOriginCount++
+            if (state.prune.tools.delete(toolId)) {
+                removedToolCount++
+            }
+        }
+    }
+
+    if (removedToolCount > 0 || removedOriginCount > 0) {
+        logger.info("Synced prune origins", {
+            removedToolCount,
+            removedOriginCount,
+        })
+    }
+}
diff --git a/lib/messages/utils.ts b/lib/messages/utils.ts
index 1b9d31c7..59994f98 100644
--- a/lib/messages/utils.ts
+++ b/lib/messages/utils.ts
@@ -84,10 +84,15 @@ export const createSyntheticToolPart = (
     const partId = generateStableId("prt_dcp_tool", deterministicSeed)
     const callId = generateStableId("call_dcp_tool", deterministicSeed)
 
-    // Gemini requires thoughtSignature bypass to accept synthetic tool parts
+    // Gemini requires a thought signature on synthetic function calls.
+    // Keep this metadata both on the part and on state so whichever
+    // conversion path is used can forward it to providerOptions.
     const toolPartMetadata = isGeminiModel(modelID)
-        ? { google: { thoughtSignature: "skip_thought_signature_validator" } }
-        : {}
+        ? {
+              google: { thoughtSignature: "skip_thought_signature_validator" },
+              vertex: { thoughtSignature: "skip_thought_signature_validator" },
+          }
+        : undefined
 
     return {
         id: partId,
@@ -96,14 +101,15 @@ export const createSyntheticToolPart = (
         type: "tool" as const,
         callID: callId,
         tool: "context_info",
+        ...(toolPartMetadata ? { metadata: toolPartMetadata } : {}),
         state: {
             status: "completed" as const,
             input: {},
             output: content,
             title: "Context Info",
-            metadata: toolPartMetadata,
+            ...(toolPartMetadata ? { metadata: toolPartMetadata } : {}),
             time: { start: now, end: now },
-        },
+        } as any,
     }
 }
 
diff --git a/lib/state/persistence.ts b/lib/state/persistence.ts
index 4652ce18..a57e1be3 100644
--- a/lib/state/persistence.ts
+++ b/lib/state/persistence.ts
@@ -8,7 +8,7 @@ import * as fs from "fs/promises"
 import { existsSync } from "fs"
 import { homedir } from "os"
 import { join } from "path"
-import type { SessionState, SessionStats, CompressSummary } from "./types"
+import type { SessionState, SessionStats, CompressSummary, PruneOrigin } from "./types"
 import type { Logger } from "../logger"
 
 /** Prune state as stored on disk */
@@ -16,6 +16,7 @@ export interface PersistedPrune {
     // New format: tool/message IDs with token counts
     tools?: Record<string, number>
     messages?: Record<string, number>
+    origins?: Record<string, PruneOrigin>
     // Legacy format: plain ID arrays (backward compatibility)
     toolIds?: string[]
     messageIds?: string[]
@@ -64,6 +65,7 @@ export async function saveSessionState(
             prune: {
                 tools: Object.fromEntries(sessionState.prune.tools),
                 messages: Object.fromEntries(sessionState.prune.messages),
+                origins: Object.fromEntries(sessionState.prune.origins),
             },
             compressSummaries: sessionState.compressSummaries,
             stats: sessionState.stats,
diff --git a/lib/state/state.ts b/lib/state/state.ts
index a9f34ddf..d59fa8f3 100644
--- a/lib/state/state.ts
+++ b/lib/state/state.ts
@@ -7,6 +7,7 @@ import {
     countTurns,
     resetOnCompaction,
     loadPruneMap,
+    loadPruneOriginMap,
 } from "./utils"
 import { getLastUserMessage } from "../shared-utils"
 
@@ -67,6 +68,7 @@ export function createSessionState(): SessionState {
         prune: {
             tools: new Map<string, number>(),
             messages: new Map<string, number>(),
+            origins: new Map(),
         },
         compressSummaries: [],
         stats: {
@@ -97,6 +99,7 @@ export function resetSessionState(state: SessionState): void {
     state.prune = {
         tools: new Map<string, number>(),
         messages: new Map<string, number>(),
+        origins: new Map(),
     }
     state.compressSummaries = []
     state.stats = {
@@ -151,6 +154,7 @@ export async function ensureSessionInitialized(
 
     state.prune.tools = loadPruneMap(persisted.prune.tools, persisted.prune.toolIds)
     state.prune.messages = loadPruneMap(persisted.prune.messages, persisted.prune.messageIds)
+    state.prune.origins = loadPruneOriginMap(persisted.prune.origins)
     state.compressSummaries = persisted.compressSummaries || []
     state.stats = {
         pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
diff --git a/lib/state/types.ts b/lib/state/types.ts
index 218756cc..683f1ced 100644
--- a/lib/state/types.ts
+++ b/lib/state/types.ts
@@ -27,9 +27,23 @@ export interface CompressSummary {
     summary: string
 }
 
+export type PruneOriginSource =
+    | "prune"
+    | "distill"
+    | "sweep"
+    | "deduplication"
+    | "supersedeWrites"
+    | "purgeErrors"
+
+export interface PruneOrigin {
+    source: PruneOriginSource
+    originMessageId: string
+}
+
 export interface Prune {
     tools: Map<string, number>
     messages: Map<string, number>
+    origins: Map<string, PruneOrigin>
 }
 
 export interface PendingManualTrigger {
diff --git a/lib/state/utils.ts b/lib/state/utils.ts
index f5e0918b..163ccf18 100644
--- a/lib/state/utils.ts
+++ b/lib/state/utils.ts
@@ -1,4 +1,4 @@
-import type { SessionState, WithParts } from "./types"
+import type { PruneOrigin, SessionState, WithParts } from "./types"
 import { isMessageCompacted } from "../shared-utils"
 
 export async function isSubAgentSession(client: any, sessionID: string): Promise<boolean> {
@@ -45,10 +45,32 @@ export function loadPruneMap(
     return new Map()
 }
 
+export function loadPruneOriginMap(obj?: Record<string, PruneOrigin>): Map<string, PruneOrigin> {
+    if (!obj || typeof obj !== "object") {
+        return new Map()
+    }
+
+    const entries: [string, PruneOrigin][] = []
+    for (const [toolId, origin] of Object.entries(obj)) {
+        if (
+            origin &&
+            typeof origin === "object" &&
+            typeof origin.source === "string" &&
+            typeof origin.originMessageId === "string" &&
+            origin.originMessageId.length > 0
+        ) {
+            entries.push([toolId, origin])
+        }
+    }
+
+    return new Map(entries)
+}
+
 export function resetOnCompaction(state: SessionState): void {
     state.toolParameters.clear()
     state.prune.tools = new Map<string, number>()
     state.prune.messages = new Map<string, number>()
+    state.prune.origins = new Map()
     state.compressSummaries = []
     state.messageIds = {
         byRawId: new Map<string, string>(),
diff --git a/lib/strategies/deduplication.ts b/lib/strategies/deduplication.ts
index aff2d019..5c6f5748 100644
--- a/lib/strategies/deduplication.ts
+++ b/lib/strategies/deduplication.ts
@@ -2,6 +2,7 @@ import { PluginConfig } from "../config"
 import { Logger } from "../logger"
 import type { SessionState, WithParts } from "../state"
 import { getFilePathsFromParameters, isProtected } from "../protected-file-patterns"
+import { getLastUserMessage } from "../shared-utils"
 import { getTotalToolTokens } from "./utils"
 
 /**
@@ -79,11 +80,21 @@ export const deduplicate = (
     }
 
     state.stats.totalPruneTokens += getTotalToolTokens(state, newPruneIds)
+    const decisionMessageId = getLastUserMessage(messages)?.info.id || ""
 
     if (newPruneIds.length > 0) {
+        if (!decisionMessageId) {
+            logger.warn("Deduplication prune origin unavailable - missing user message")
+        }
         for (const id of newPruneIds) {
             const entry = state.toolParameters.get(id)
             state.prune.tools.set(id, entry?.tokenCount ?? 0)
+            if (decisionMessageId) {
+                state.prune.origins.set(id, {
+                    source: "deduplication",
+                    originMessageId: decisionMessageId,
+                })
+            }
         }
         logger.debug(`Marked ${newPruneIds.length} duplicate tool calls for pruning`)
     }
diff --git a/lib/strategies/purge-errors.ts b/lib/strategies/purge-errors.ts
index 25939eda..b579cafe 100644
--- a/lib/strategies/purge-errors.ts
+++ b/lib/strategies/purge-errors.ts
@@ -2,6 +2,7 @@ import { PluginConfig } from "../config"
 import { Logger } from "../logger"
 import type { SessionState, WithParts } from "../state"
 import { getFilePathsFromParameters, isProtected } from "../protected-file-patterns"
+import { getLastUserMessage } from "../shared-utils"
 import { getTotalToolTokens } from "./utils"
 
 /**
@@ -72,10 +73,20 @@ export const purgeErrors = (
     }
 
     if (newPruneIds.length > 0) {
+        const decisionMessageId = getLastUserMessage(messages)?.info.id || ""
+        if (!decisionMessageId) {
+            logger.warn("Purge errors prune origin unavailable - missing user message")
+        }
         state.stats.totalPruneTokens += getTotalToolTokens(state, newPruneIds)
         for (const id of newPruneIds) {
             const entry = state.toolParameters.get(id)
             state.prune.tools.set(id, entry?.tokenCount ?? 0)
+            if (decisionMessageId) {
+                state.prune.origins.set(id, {
+                    source: "purgeErrors",
+                    originMessageId: decisionMessageId,
+                })
+            }
         }
         logger.debug(
             `Marked ${newPruneIds.length} error tool calls for pruning (older than ${turnThreshold} turns)`,
diff --git a/lib/strategies/supersede-writes.ts b/lib/strategies/supersede-writes.ts
index e61b1d0a..ea8b142f 100644
--- a/lib/strategies/supersede-writes.ts
+++ b/lib/strategies/supersede-writes.ts
@@ -2,6 +2,7 @@ import { PluginConfig } from "../config"
 import { Logger } from "../logger"
 import type { SessionState, WithParts } from "../state"
 import { getFilePathsFromParameters, isProtected } from "../protected-file-patterns"
+import { getLastUserMessage } from "../shared-utils"
 import { getTotalToolTokens } from "./utils"
 
 /**
@@ -105,10 +106,20 @@ export const supersedeWrites = (
     }
 
     if (newPruneIds.length > 0) {
+        const decisionMessageId = getLastUserMessage(messages)?.info.id || ""
+        if (!decisionMessageId) {
+            logger.warn("Supersede writes prune origin unavailable - missing user message")
+        }
         state.stats.totalPruneTokens += getTotalToolTokens(state, newPruneIds)
         for (const id of newPruneIds) {
             const entry = state.toolParameters.get(id)
             state.prune.tools.set(id, entry?.tokenCount ?? 0)
+            if (decisionMessageId) {
+                state.prune.origins.set(id, {
+                    source: "supersedeWrites",
+                    originMessageId: decisionMessageId,
+                })
+            }
         }
         logger.debug(`Marked ${newPruneIds.length} superseded write tool calls for pruning`)
     }
diff --git a/lib/tools/distill.ts b/lib/tools/distill.ts
index b67d56b4..6cbd56d6 100644
--- a/lib/tools/distill.ts
+++ b/lib/tools/distill.ts
@@ -53,6 +53,7 @@ export function createDistillTool(ctx: PruneToolContext): ReturnType<typeof tool
                 ids,
                 "extraction" as PruneReason,
                 "Distill",
+                "distill",
                 distillations,
             )
         },
diff --git a/lib/tools/prune-shared.ts b/lib/tools/prune-shared.ts
index 6555c4ae..5d0e5cbb 100644
--- a/lib/tools/prune-shared.ts
+++ b/lib/tools/prune-shared.ts
@@ -1,4 +1,4 @@
-import type { SessionState, ToolParameterEntry, WithParts } from "../state"
+import type { PruneOriginSource, SessionState, ToolParameterEntry, WithParts } from "../state"
 import type { PluginConfig } from "../config"
 import type { Logger } from "../logger"
 import type { PruneToolContext } from "./types"
@@ -14,10 +14,11 @@ import { buildToolIdList } from "../messages/utils"
 // Shared logic for executing prune operations.
 export async function executePruneOperation(
     ctx: PruneToolContext,
-    toolCtx: { sessionID: string },
+    toolCtx: { sessionID: string; messageID?: string },
     ids: string[],
     reason: PruneReason,
     toolName: string,
+    source: PruneOriginSource,
     distillation?: string[],
 ): Promise<string> {
     const { client, state, logger, config, workingDirectory } = ctx
@@ -114,6 +115,12 @@ export async function executePruneOperation(
             continue
         }
 
+        if (state.prune.tools.has(id)) {
+            logger.debug("Rejecting prune request - already pruned", { index, id })
+            skippedIds.push(index.toString())
+            continue
+        }
+
         validNumericIds.push(index)
     }
 
@@ -126,9 +133,21 @@ export async function executePruneOperation(
     }
 
     const pruneToolIds: string[] = validNumericIds.map((index) => toolIdList[index])
+    const originMessageId =
+        typeof toolCtx.messageID === "string" && toolCtx.messageID.length > 0
+            ? toolCtx.messageID
+            : ""
+
+    if (!originMessageId) {
+        logger.warn(`Missing tool message ID for ${toolName} prune origin tracking`)
+    }
+
     for (const id of pruneToolIds) {
         const entry = state.toolParameters.get(id)
         state.prune.tools.set(id, entry?.tokenCount ?? 0)
+        if (originMessageId) {
+            state.prune.origins.set(id, { source, originMessageId })
+        }
     }
 
     const toolMetadata = new Map<string, ToolParameterEntry>()
@@ -167,7 +186,7 @@ export async function executePruneOperation(
 
     let result = formatPruningResultForTool(pruneToolIds, toolMetadata, workingDirectory)
     if (skippedIds.length > 0) {
-        result += `\n\nNote: ${skippedIds.length} IDs were skipped (invalid, protected, or missing metadata): ${skippedIds.join(", ")}`
+        result += `\n\nNote: ${skippedIds.length} IDs were skipped (invalid, protected, already pruned, or missing metadata): ${skippedIds.join(", ")}`
     }
     return result
 }
diff --git a/lib/tools/prune.ts b/lib/tools/prune.ts
index 17065aa9..1cd19a51 100644
--- a/lib/tools/prune.ts
+++ b/lib/tools/prune.ts
@@ -30,7 +30,7 @@ export function createPruneTool(ctx: PruneToolContext): ReturnType<typeof tool>
             const numericIds = args.ids
             const reason = "noise"
 
-            return executePruneOperation(ctx, toolCtx, numericIds, reason, "Prune")
+            return executePruneOperation(ctx, toolCtx, numericIds, reason, "Prune", "prune")
         },
     })
 }