@cortexkit/opencode-magic-context 0.41.4 → 0.42.1

package/src/shared/status-detail-text.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import type { StatusDetail } from "./rpc-types";
-import { formatStatusDetailMarkdown } from "./status-detail-text";
+import { formatStatusDetailMarkdown, formatStatusDiagnosticsMarkdown } from "./status-detail-text";
 
 const STATUS_FIXTURE: StatusDetail = {
     sessionId: "ses_status",
@@ -17,9 +17,11 @@ const STATUS_FIXTURE: StatusDetail = {
     compartmentInProgress: true,
     sessionNoteCount: 1,
     readySmartNoteCount: 2,
-    cacheTtl: "5m",
-    cacheTtlSource: "session",
+    cacheTtl: "1h",
+    cacheTtlSource: "config",
+    cacheTtlModelKey: "anthropic/claude-opus-5",
     lastTransformError: null,
+    historianFailureCount: 0,
     lastDreamerRunAt: null,
     projectIdentity: "/repo",
     compartmentTokens: 22_000,
@@ -61,36 +63,106 @@ const STATUS_FIXTURE: StatusDetail = {
         lastErrorMessage: null,
         lastErrorTime: null,
     },
+    tailHygiene: {
+        u: 14_400,
+        t: 48_000,
+        severity: 0.3,
+        evaluable: true,
+        generationInvalidated: false,
+        baselineGeneration: 3,
+        computedAt: 1_730_000_000_000,
+        reclaimableToolOutputCount: 3,
+    },
+    embedding: {
+        state: "running",
+        indexed: 9,
+        total: 12,
+    },
     storage_versions: {
         context_db_schema_version: 79,
         plugin_supported_version: 79,
     },
 };
 
-describe("formatStatusDetailMarkdown", () => {
-    test("renders the fixed TUI status payload as compact markdown", () => {
+describe("status detail text", () => {
+    test("renders the OpenCode summary golden", () => {
         expect(formatStatusDetailMarkdown(STATUS_FIXTURE)).toBe(`## Magic Context Status
 
-- **Mode:** Magic Context compaction
-- **Active profile:** work
-- **Usage:** 75.0% (96,000 / 128,000 usable tokens)
-- **Cache TTL: 5m (session)**; live (42s remaining); TTL 5m
-- **Historian:** running; boundary present; coverage 12
-- **Memory:** 8 active; 3 injected
-- **Tags:** 4 active, 1 dropped; 2 pending drops
-- **Execute threshold:** 65.0%`);
+- **Context:** 75.0% of usable context (96,000 / 128,000 tokens)
+- **Cache lifetime:** 1h (config for anthropic/claude-opus-5)
+- **Automatic compression:** at 65.0% of usable context
+- **History compression:** Compressing history · 12 history blocks
+- **Reclaimable:** 3 spent tool outputs (~14k tokens)
+- **Memory:** 8 memories · 3 notes
+- **Search indexing:** Running · 9 / 12 history blocks indexed`);
     });
 
-    test("shows module-routed host paths only in Rust-mode chat fallback", () => {
-        const rustStatus = formatStatusDetailMarkdown({
+    test("renders disabled automatic compression and an empty reclaimable set without a gauge", () => {
+        const rendered = formatStatusDetailMarkdown({
+            ...STATUS_FIXTURE,
+            compaction_enabled: false,
+            tailHygiene: {
+                ...STATUS_FIXTURE.tailHygiene!,
+                u: 0,
+                reclaimableToolOutputCount: 0,
+            },
+        });
+        expect(rendered).toContain("- **Automatic compression:** Off");
+        expect(rendered).toContain("- **Reclaimable:** none");
+        expect(rendered).not.toContain("Reclaimable: 0");
+    });
+
+    test("renders summary and diagnostics from one snapshot with matching status values", () => {
+        const summary = formatStatusDetailMarkdown(STATUS_FIXTURE);
+        const diagnostics = formatStatusDiagnosticsMarkdown(STATUS_FIXTURE);
+        for (const value of ["75.0%", "65.0%", "1h (config for anthropic/claude-opus-5)"]) {
+            expect(summary).toContain(value);
+            expect(diagnostics).toContain(value);
+        }
+    });
+
+    test("keeps the previous OpenCode detail behind diagnostics", () => {
+        const diagnostics = formatStatusDiagnosticsMarkdown(STATUS_FIXTURE);
+        expect(diagnostics).toContain("- **Active profile:** work");
+        expect(diagnostics).toContain("- **Tags:** 4 active, 1 dropped; 2 pending drops");
+        expect(diagnostics).toContain("- **Execute threshold:** 65.0%");
+    });
+
+    test("keeps internal vocabulary and identifiers out of the summary", () => {
+        const summary = formatStatusDetailMarkdown({
             ...STATUS_FIXTURE,
+            sessionId: "session-secret",
+            projectIdentity: "/Users/example/secret-project",
             hostBackendsModuleSide: true,
+            lastTransformError: "facade MODULE drain failed in mc-store /tmp/private",
+            historianFailureCount: 2,
         });
-        const tsStatus = formatStatusDetailMarkdown(STATUS_FIXTURE);
+        for (const forbidden of [
+            "session-secret",
+            "/Users/",
+            "tag counter",
+            "protection",
+            "formula",
+            "MODULE",
+            "mc-store",
+            "harness",
+            "compartment",
+            "facade",
+            "changefeed",
+            "drain",
+        ]) {
+            expect(summary.toLowerCase()).not.toContain(forbidden.toLowerCase());
+        }
+        expect(summary).toContain("(MC-S02)");
+        expect(summary).toContain("(MC-H01)");
+    });
 
-        expect(rustStatus).toContain(
-            "Host backends → MODULE: ctx_memory, ctx_note; historian: module-side",
-        );
-        expect(tsStatus).not.toContain("Host backends → MODULE");
+    test("does not expose module routing in the summary", () => {
+        const rustStatus = formatStatusDetailMarkdown({
+            ...STATUS_FIXTURE,
+            hostBackendsModuleSide: true,
+        });
+        expect(rustStatus).not.toContain("MODULE");
+        expect(rustStatus).not.toContain("mc-store");
     });
 });

package/src/shared/status-detail-text.ts

@@ -1,7 +1,16 @@
 import { formatCacheTtlDisplay } from "./cache-ttl-display";
 import { formatConfigParseStatusLine } from "./config-diagnostics";
+import {
+    formatOpenCodeDbMissingStatusLine,
+    formatOpenCodeDbReadFailureStatusLine,
+    getOpenCodeDbReadFailure,
+    openCodeDbPathExists,
+    resolveOpenCodeDbPath,
+} from "./opencode-db-path";
 import type { StatusDetail } from "./rpc-types";
 import { RUST_MODE_HOST_PATHS_LINE } from "./rust-mode-status";
+import { renderUserStatusSummary, statusSummaryFromDetail } from "./status-summary";
+import { renderUserFacingFailure } from "./user-facing-codes";
 
 function formatCount(value: number): string {
     return Math.round(value).toLocaleString();
@@ -14,8 +23,13 @@ function formatCacheLane(detail: StatusDetail): string {
     return `live (${Math.round(detail.cacheRemainingMs / 1000)}s remaining); TTL ${detail.cacheTtl}`;
 }
 
-/** Render the same StatusDetail payload that powers the TUI dialog for chat-only clients. */
+/** Render the default user summary for chat-only OpenCode clients. */
 export function formatStatusDetailMarkdown(detail: StatusDetail): string {
+    return renderUserStatusSummary(statusSummaryFromDetail(detail), "markdown");
+}
+
+/** Render the opt-in operator detail that the status dialog exposes behind Diagnostics. */
+export function formatStatusDiagnosticsMarkdown(detail: StatusDetail): string {
     const usableLimit =
         detail.contextLimit > 0
             ? `${formatCount(detail.contextLimit)} usable tokens`
@@ -29,12 +43,20 @@ export function formatStatusDetailMarkdown(detail: StatusDetail): string {
             ? undefined
             : `coverage ${detail.coverageOrdinal === null ? "none" : detail.coverageOrdinal}`,
     ].filter((value): value is string => value !== undefined);
+    const openCodeDbResolution = resolveOpenCodeDbPath();
+    const openCodeDbReadFailure = getOpenCodeDbReadFailure();
+    const openCodeDbStatusLine = !openCodeDbPathExists(openCodeDbResolution)
+        ? formatOpenCodeDbMissingStatusLine(openCodeDbResolution)
+        : openCodeDbReadFailure?.path === openCodeDbResolution.path
+          ? formatOpenCodeDbReadFailureStatusLine(openCodeDbReadFailure)
+          : null;
     const mode =
         detail.compaction_enabled === false
             ? "native compaction (Magic Context history compaction disabled)"
             : "Magic Context compaction";
 
     const lines = [
+        ...(openCodeDbStatusLine ? [openCodeDbStatusLine, ""] : []),
         ...(detail.configParseFailures ?? []).map(formatConfigParseStatusLine),
         ...((detail.configParseFailures?.length ?? 0) > 0 ? [""] : []),
         "## Magic Context Status",
@@ -56,7 +78,7 @@ export function formatStatusDetailMarkdown(detail: StatusDetail): string {
         );
     }
     if (detail.lastTransformError) {
-        lines.push(`- **Last transform error:** ${detail.lastTransformError}`);
+        lines.push(`- **Warning:** ${renderUserFacingFailure("transform_update_failed")}`);
     }
 
     return lines.join("\n");

package/src/shared/status-summary.ts

@@ -0,0 +1,167 @@
+import { formatCacheTtlDisplay } from "./cache-ttl-display";
+import type { StatusDetail } from "./rpc-types";
+import { renderUserFacingFailure, type UserFacingFailureKey } from "./user-facing-codes";
+
+export type StatusCompressionState = "off" | "compressing" | "ready" | "waiting";
+export type StatusEmbeddingState = "off" | "running" | "paused" | "stopped" | "ready" | "waiting";
+
+export interface UserStatusSummary {
+    inputTokens: number;
+    usableContextTokens: number;
+    usagePercentage: number;
+    cacheLifetime: string;
+    automaticCompressionThreshold: number | null;
+    compression: {
+        state: StatusCompressionState;
+        historyBlockCount: number;
+    };
+    reclaimable: {
+        toolOutputCount: number;
+        tokens: number;
+    };
+    memoryCount: number;
+    noteCount: number;
+    embedding: {
+        state: StatusEmbeddingState;
+        indexed: number;
+        total: number;
+    };
+    warnings: UserFacingFailureKey[];
+}
+
+export function statusSummaryFromDetail(detail: StatusDetail): UserStatusSummary {
+    const compressionState: StatusCompressionState =
+        detail.compaction_enabled === false
+            ? "off"
+            : detail.historianRunning ||
+                detail.compartmentInProgress ||
+                (detail.recompProgress?.phase === "recomp" &&
+                    detail.recompProgress.kind !== "embed")
+              ? "compressing"
+              : detail.compartmentCount > 0
+                ? "ready"
+                : "waiting";
+    const warnings: UserFacingFailureKey[] = [];
+    if (detail.lastTransformError) warnings.push("transform_update_failed");
+    if ((detail.historianFailureCount ?? 0) > 0) warnings.push("historian_unavailable");
+    if ((detail.configParseFailures?.length ?? 0) > 0) warnings.push("configuration_warning");
+    if (detail.embedding?.state === "stopped") warnings.push("embedding_unavailable");
+    if ((detail.loggerDiagnostics?.swallowedWriteCount ?? 0) > 0) {
+        warnings.push("status_log_unavailable");
+    }
+
+    return {
+        inputTokens: detail.inputTokens,
+        usableContextTokens: detail.contextLimit,
+        usagePercentage: detail.usagePercentage,
+        cacheLifetime: formatCacheTtlDisplay({
+            value: detail.cacheTtl,
+            source: detail.cacheTtlSource ?? "session",
+            modelKey: detail.cacheTtlModelKey,
+        }).replace(/^Cache TTL:\s*/, ""),
+        automaticCompressionThreshold:
+            detail.compaction_enabled === false ? null : detail.executeThreshold,
+        compression: {
+            state: compressionState,
+            historyBlockCount: detail.compartmentCount,
+        },
+        reclaimable: {
+            toolOutputCount: detail.tailHygiene?.reclaimableToolOutputCount ?? 0,
+            tokens: detail.tailHygiene?.u ?? 0,
+        },
+        memoryCount: detail.memoryCount,
+        noteCount: (detail.sessionNoteCount ?? 0) + (detail.readySmartNoteCount ?? 0),
+        embedding: detail.embedding ?? {
+            state: "waiting",
+            indexed: 0,
+            total: 0,
+        },
+        warnings: [...new Set(warnings)],
+    };
+}
+
+function formatCount(value: number): string {
+    return Math.round(value).toLocaleString();
+}
+
+function compressionText(summary: UserStatusSummary): string {
+    const historyBlocks = `${summary.compression.historyBlockCount} history block${
+        summary.compression.historyBlockCount === 1 ? "" : "s"
+    }`;
+    switch (summary.compression.state) {
+        case "off":
+            return "Off";
+        case "compressing":
+            return `Compressing history · ${historyBlocks}`;
+        case "ready":
+            return `Ready · ${historyBlocks}`;
+        case "waiting":
+            return "Waiting for enough conversation history";
+    }
+}
+
+function reclaimableText(summary: UserStatusSummary): string {
+    const count = Math.max(0, Math.floor(summary.reclaimable.toolOutputCount));
+    if (count === 0) return "none";
+    const outputs = `${count} spent tool output${count === 1 ? "" : "s"}`;
+    return `${outputs} (~${Math.round(Math.max(0, summary.reclaimable.tokens) / 1000)}k tokens)`;
+}
+
+function embeddingText(summary: UserStatusSummary): string {
+    if (summary.embedding.state === "off") return "Off";
+    const coverage = `${formatCount(summary.embedding.indexed)} / ${formatCount(summary.embedding.total)} history blocks indexed`;
+    switch (summary.embedding.state) {
+        case "running":
+            return `Running · ${coverage}`;
+        case "paused":
+            return `Paused · ${coverage}`;
+        case "stopped":
+            return `Paused after an issue · ${coverage}`;
+        case "ready":
+            return `Ready · ${coverage}`;
+        case "waiting":
+            return `Waiting · ${coverage}`;
+    }
+}
+
+export function renderUserStatusSummary(
+    summary: UserStatusSummary,
+    style: "markdown" | "plain",
+): string {
+    const context = `${summary.usagePercentage.toFixed(1)}% of usable context (${formatCount(summary.inputTokens)} / ${
+        summary.usableContextTokens > 0 ? formatCount(summary.usableContextTokens) : "?"
+    } tokens)`;
+    const values = [
+        ["Context", context],
+        ["Cache lifetime", summary.cacheLifetime],
+        [
+            "Automatic compression",
+            summary.automaticCompressionThreshold === null
+                ? "Off"
+                : `at ${summary.automaticCompressionThreshold.toFixed(1)}% of usable context`,
+        ],
+        ["History compression", compressionText(summary)],
+        ["Reclaimable", reclaimableText(summary)],
+        [
+            "Memory",
+            `${formatCount(summary.memoryCount)} memories · ${formatCount(summary.noteCount)} notes`,
+        ],
+        ["Search indexing", embeddingText(summary)],
+    ] as const;
+    const lines =
+        style === "markdown"
+            ? [
+                  "## Magic Context Status",
+                  "",
+                  ...values.map(([label, value]) => `- **${label}:** ${value}`),
+              ]
+            : ["Magic Context Status", ...values.map(([label, value]) => `${label}: ${value}`)];
+    for (const warning of summary.warnings) {
+        lines.push(
+            style === "markdown"
+                ? `- **Warning:** ${renderUserFacingFailure(warning)}`
+                : `Warning: ${renderUserFacingFailure(warning)}`,
+        );
+    }
+    return lines.join("\n");
+}

package/src/shared/subagent-runner.ts

@@ -1,7 +1,7 @@
 /**
  * Cross-harness subagent runner abstraction.
  *
- * Magic Context spawns three kinds of subagents — historian, dreamer, sidekick —
+ * Magic Context spawns historian and Dreamer subagents
  * each as a child "session" with its own model/prompt/tools. OpenCode and Pi
  * have very different APIs for this:
  *
@@ -15,15 +15,15 @@
  *     disk, optionally addressed via `--session <path>`.
  *
  * The runner interface below normalizes both into the same shape so the
- * actual subagent business logic (historian XML parsing, dreamer task loop,
- * sidekick augmentation) can stay harness-agnostic. Each harness ships its
+ * actual subagent business logic (historian XML parsing and Dreamer task loops)
+ * can stay harness-agnostic. Each harness ships its
  * own runner implementation; agents take a `SubagentRunner` as a dep instead
  * of reaching for `client.session.*` directly.
  *
  * Step 5a (this commit) defines the contract and ships `PiSubagentRunner`.
  * Step 5b will refactor the OpenCode-side spawn paths in
- * `compartment-runner-historian.ts`, `dreamer/runner.ts`, and
- * `sidekick/agent.ts` onto an `OpenCodeSubagentRunner` so both harnesses
+ * `compartment-runner-historian.ts` and `dreamer/runner.ts` onto an
+ * `OpenCodeSubagentRunner` so both harnesses
  * share the agent business logic instead of duplicating it. Until 5b lands,
  * OpenCode keeps its existing direct `client.session.*` calls untouched —
  * the runner contract is purely additive on the OpenCode side.
@@ -36,11 +36,11 @@ import type { ModelInput } from "./model-resolution";
  *
  * Mirrors the union of OpenCode's `session.create` + `session.prompt` body
  * fields and Pi's `--print` CLI flags, picking the shared subset that all
- * three subagent kinds (historian, dreamer, sidekick) actually use today.
+ * the historian and Dreamer subagents actually use today.
  *
  * Fields:
  * - `agent`: harness-specific agent name. OpenCode looks this up in its
- *   agent registry (`HISTORIAN_AGENT`, `DREAMER_AGENT`, `SIDEKICK_AGENT`).
+ *   agent registry (`HISTORIAN_AGENT`, `DREAMER_AGENT`).
  *   Pi has no concept of "agent name" beyond config, so this is ignored
  *   on the Pi side and used only by `OpenCodeSubagentRunner`.
  * - `systemPrompt`: full system prompt for this child run. Replaces (not
@@ -88,7 +88,7 @@ export interface SubagentRunOptions {
     /**
      * Optional progress callback. The runner invokes it for milestone events
      * during the run: spawn, first event received, terminal stop reason
-     * detected, child exit. Used by historian/dreamer/sidekick to write
+     * detected, child exit. Used by historian/dreamer to write
      * lifecycle entries to the magic-context.log without polluting the
      * normal stdout stream.
      *
@@ -104,7 +104,6 @@ export interface SubagentRunOptions {
         | "historian_editor"
         | "compressor"
         | "dreamer"
-        | "sidekick"
         | "user_memory_review"
         | "recomp"
         | undefined;
@@ -182,6 +181,11 @@ export type SubagentProgressEvent =
  *   here so the OpenCode runner can surface the child session ID for log
  *   correlation when Step 5b lands.
  */
+export interface CompletedSubagentToolCall {
+    name: string;
+    arguments: Record<string, unknown>;
+}
+
 export type SubagentRunResult =
     | {
           ok: true;
@@ -196,6 +200,9 @@ export type SubagentRunResult =
            * the real session messages.
            */
           toolCallCount?: number;
+          /** Completed, non-error tool results preserved by runners that can
+           *  reconstruct invocation/result pairs from their transcript. */
+          completedToolCalls?: CompletedSubagentToolCall[];
           meta?: Record<string, unknown>;
       }
     | {
@@ -222,7 +229,7 @@ export type SubagentRunResult =
  *
  * Each harness ships a single instance — the OpenCode plugin wires
  * `OpenCodeSubagentRunner` and the Pi plugin wires `PiSubagentRunner` in
- * its `extension` boot path. Agent code (historian, dreamer, sidekick)
+ * its `extension` boot path. Agent code (historian and dreamer)
  * receives the runner as a dep and never reaches for harness-specific
  * client APIs directly.
  */

package/src/shared/tag-transcript.ts

@@ -55,6 +55,7 @@ import {
     updateTagTokenCount,
 } from "../features/magic-context/storage-tags";
 import { makeToolCompositeKey, type Tagger } from "../features/magic-context/tagger";
+import { droppedInputMarker } from "../hooks/magic-context/dropped-input-guard";
 import { applyEditMarkerToInput } from "../hooks/magic-context/edit-marker";
 import { estimateImageTokensFromDataUrl } from "../hooks/magic-context/image-token-estimate";
 import { estimateTokens } from "../hooks/magic-context/read-session-formatting";
@@ -247,7 +248,8 @@ export function tagTranscript(
         let toolResultOrdinal = 0;
         const parts = message.parts;
         const messageHasNativeReasoning =
-            message.info.role === "assistant" && parts.some((part) => part.kind === "thinking");
+            message.requiresToolArcSkeleton ??
+            (message.info.role === "assistant" && parts.some((part) => part.kind === "thinking"));
         const contentDerivedTextIds =
             messageId !== undefined && options.textIdentityDriftMessageIds?.has(messageId) === true
                 ? buildContentDerivedTextIds(messageId, parts)
@@ -1056,8 +1058,20 @@ function buildAggregateTarget(
             }
             return occurrences[0]?.part.getText() ?? null;
         },
-        drop(): "removed" | "absent" {
-            // Replace BOTH halves with the dropped sentinel.
+        drop(): "removed" | "absent" | "incomplete" {
+            const complete =
+                occurrences.some((occ) => occ.kind === "tool_use") &&
+                occurrences.some((occ) => occ.kind === "tool_result");
+            if (!complete) return "incomplete";
+            if (
+                !requiresToolArcSkeleton &&
+                occurrences.every((occ) => occ.part.remove && occ.part.canRemove?.() !== false)
+            ) {
+                let removed = false;
+                for (const occ of occurrences) removed = occ.part.remove?.() || removed;
+                return removed ? "removed" : "absent";
+            }
+            // Adapters without structural removal retain paired sentinels.
             const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
             let any = false;
             for (const occ of occurrences) {
@@ -1066,14 +1080,14 @@ function buildAggregateTarget(
             return any ? "removed" : "absent";
         },
         truncate(): "truncated" | "absent" {
-            // Skeleton-drop: replace BOTH halves' content with the one
-            // canonical `[dropped §N§]` placeholder (byte-identical to a full
-            // drop and to OpenCode). Frozen by the dropMode column → replays
-            // the same string every pass. The tool_use call survives intact.
+            // Keep the paired call shell, but replace its arguments with one
+            // non-executable marker; result halves carry the matching sentinel.
             const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
             let any = false;
             for (const occ of occurrences) {
-                if (setToolContentOrText(occ.part, sentinel)) {
+                if (occ.kind === "tool_use" && occ.part.setToolInput) {
+                    if (occ.part.setToolInput(droppedInputMarker(tagId))) any = true;
+                } else if (setToolContentOrText(occ.part, sentinel)) {
                     any = true;
                 }
             }
@@ -1101,12 +1115,12 @@ function buildAggregateTarget(
             }
             return any ? "truncated" : "absent";
         },
-        // Non-mutating reclaim predicate (Pi parity with OpenCode's canDrop).
-        // Pi sentinelizes BOTH halves, so unlike OpenCode there's no
-        // result-part requirement — a target reclaims as long as it still has
-        // at least one live occurrence to sentinelize.
+        // Open invocations still belong to the current turn; only complete arcs reclaim.
         canDrop(): boolean {
-            return occurrences.length > 0;
+            return (
+                occurrences.some((occ) => occ.kind === "tool_use") &&
+                occurrences.some((occ) => occ.kind === "tool_result")
+            );
         },
         requiresToolArcSkeleton,
         // Non-mutating read of the invocation input (the tool_use occurrence
@@ -1162,8 +1176,8 @@ function buildTextTarget(
  * TagTarget for a tag-eligible tool part. Tool parts get full-drop or
  * skeleton-drop treatment from `applyFlushedStatuses` based on the stored
  * `drop_mode` column. Both render the SAME canonical `[dropped §N§]`
- * placeholder — full-drop replaces the whole pair, skeleton-drop keeps the
- * tool_use call and replaces only its output. One placeholder string,
+ * placeholder — full-drop replaces the whole pair, while skeleton-drop keeps
+ * the tool_use call with only a dropped-input marker. Marker bytes are
  * byte-identical across passes and across harnesses.
  */
 function buildToolTarget(
@@ -1190,12 +1204,10 @@ function buildToolTarget(
             return replaced ? "removed" : "absent";
         },
         truncate(): "truncated" | "absent" {
-            // Skeleton-drop: replace the tool output with the one canonical
-            // `[dropped §N§]` placeholder (byte-identical to a full drop and to
-            // OpenCode). Frozen by the dropMode column, so it replays the same
-            // string every pass. The tool_use call itself survives intact.
-            const ok = setToolContentOrText(part, `[dropped \u00a7${tagId}\u00a7]`);
-            return ok ? "truncated" : "absent";
+            const changed = part.setToolInput
+                ? part.setToolInput(droppedInputMarker(tagId))
+                : setToolContentOrText(part, `[dropped \u00a7${tagId}\u00a7]`);
+            return changed ? "truncated" : "absent";
         },
         message: {
             info: { id: message.info.id, role: message.info.role },

package/src/shared/tail-hygiene-status.ts

@@ -9,6 +9,7 @@ export interface WireTailHygieneBaseline {
     generation_invalidated?: boolean;
     baseline_generation?: number;
     computed_at_ms?: number;
+    reclaimable_tool_output_count?: number;
 }
 
 function finiteNumber(value: unknown, fallback = 0): number {
@@ -34,6 +35,10 @@ export function resolveTailHygieneStatus(
             generationInvalidated: rustBaseline.generation_invalidated === true,
             baselineGeneration: Math.max(0, finiteNumber(rustBaseline.baseline_generation)),
             computedAt: Math.max(0, finiteNumber(rustBaseline.computed_at_ms)),
+            reclaimableToolOutputCount: Math.max(
+                0,
+                Math.floor(finiteNumber(rustBaseline.reclaimable_tool_output_count)),
+            ),
         };
     }
     if (tsBaseline === undefined) return undefined;
@@ -47,6 +52,9 @@ export function resolveTailHygieneStatus(
         generationInvalidated: tsBaseline.generationInvalidated,
         baselineGeneration: Math.max(0, tsBaseline.baselineGeneration),
         computedAt: Math.max(0, tsBaseline.computedAt),
+        reclaimableToolOutputCount: tsBaseline.baselineParts.filter(
+            (part) => part.kind === "toolOutput" && part.uTokens > 0,
+        ).length,
     };
 }
 

package/src/shared/transcript.ts

@@ -167,6 +167,11 @@ export interface TranscriptPart {
      */
     replaceWithSentinel(sentinelText: string): boolean;
 
+    /** Remove one half of a complete tool arc. Callers must remove both halves together. */
+    remove?(): boolean;
+    /** Refuse structural deletion when the adapter cannot match provider-native identity safely. */
+    canRemove?(): boolean;
+
     /**
      * Optional: serialized byte size of the part's REAL payload, including
      * non-text content (images, structured data) that `getText()` can't
@@ -187,6 +192,8 @@ export interface TranscriptPart {
  * use `info.id` for cross-pass correlation, never the message reference.
  */
 export interface TranscriptMessage {
+    /** Override when the receiving protocol does not merge adjacent assistant reasoning turns. */
+    requiresToolArcSkeleton?: boolean;
     /**
      * Lightweight metadata exposed for tagging, sentinel persistence, and
      * cross-pass correlation. Adapters fill these from harness-native