@herbertgao/pi-extensions 2026.8.9 → 2026.8.11

package/node_modules/@herbertgao/resume-from/dist/adapters/pi/format.js

@@ -0,0 +1,223 @@
+/**
+ * Everything this tool knows about Pi's session file layout.
+ *
+ * Verified against the installed Pi 0.83.0 (`dist/core/session-manager.js`,
+ * `dist/config.js`), not assumed:
+ *
+ * - the home is Pi's agent directory: `$PI_CODING_AGENT_DIR`, else `~/.pi/agent`;
+ * - sessions live in `<home>/sessions/<encoded cwd>/<timestamp>_<id>.jsonl`;
+ * - a file is JSONL: one `session` header, then entries with `id`/`parentId`/`timestamp`;
+ * - an assistant message without a numeric `usage` object crashes Pi (C-11).
+ *
+ * When Pi changes, this file changes. Nothing outside this folder holds these facts.
+ */
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+/** Pi's current session file version (`CURRENT_SESSION_VERSION`). */
+export const PI_SESSION_VERSION = 3;
+export const SESSIONS_DIR_NAME = "sessions";
+const PI_CONFIG_DIR_NAME = ".pi";
+const PI_AGENT_DIR_NAME = "agent";
+/** Pi's own override of its agent directory (`ENV_AGENT_DIR` in Pi's config). */
+const ENV_AGENT_DIR = "PI_CODING_AGENT_DIR";
+/**
+ * The customType of the provenance entry. It is written as a `custom` entry, which Pi's
+ * `buildSessionContext` drops on the floor: the marker is stored and shown, never sent to
+ * the model (FR-47, FR-48). `src/host/pi-extension/` registers the renderer that shows it.
+ */
+export const MARKER_CUSTOM_TYPE = "resume-from-provenance";
+/** Prefix of the title of a session file that cannot be read (T-PI-13). */
+export const UNREADABLE_TITLE_PREFIX = "(unreadable) ";
+/** What replaces a tool result body (FR-24, FR-25). */
+export const DROPPED_BODY_NOTE = "(content dropped: imported session, may be stale)";
+/** Context window assumed for Pi when configuration overrides none (FR-18). */
+export const DEFAULT_WINDOW_TOKENS = 200_000;
+/** What an imported assistant turn declares about itself. It cost nothing to import. */
+export const IMPORTED_API = "resume-from";
+export const IMPORTED_PROVIDER = "resume-from";
+export const IMPORTED_MODEL = "imported-session";
+const MAX_TITLE_LENGTH = 80;
+const MAX_OUTCOME_ARGUMENTS = 60;
+/** Pi's default agent directory. Mirrors Pi's own `getAgentDir()`. */
+export function defaultPiHome() {
+    const override = process.env[ENV_AGENT_DIR];
+    if (override && override.trim().length > 0)
+        return resolve(override);
+    return join(homedir(), PI_CONFIG_DIR_NAME, PI_AGENT_DIR_NAME);
+}
+/** Pi's encoding of a working directory into one directory name. */
+export function encodeCwd(cwd) {
+    const resolved = resolve(cwd);
+    return `--${resolved.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
+export function sessionsRoot(home) {
+    return join(home, SESSIONS_DIR_NAME);
+}
+export function sessionDirFor(home, cwd) {
+    return join(sessionsRoot(home), encodeCwd(cwd));
+}
+/** Pi's own file naming: the ISO timestamp with `:` and `.` replaced, then the id. */
+export function sessionFileName(isoTimestamp, sessionId) {
+    return `${isoTimestamp.replace(/[:.]/g, "-")}_${sessionId}.jsonl`;
+}
+/** The session id Pi would read out of a session file name, or null. */
+export function sessionIdFromFileName(fileName) {
+    const match = /^.*?_(.+)\.jsonl$/.exec(fileName);
+    return match?.[1] ?? null;
+}
+/**
+ * Entry types Pi writes that carry no turn: settings, bookmarks, and extension state.
+ * They are known, so they are not reported as skipped.
+ *
+ * `custom_message` is deliberately absent. Pi's `sessionEntryToContextMessages` turns it
+ * into a real context message, so an extension can put conversation content there. This
+ * adapter does not know that content's shape, so it is skipped — and counted, so the skip
+ * is visible rather than a silent shortening of the session.
+ */
+export const NON_TURN_ENTRY_TYPES = new Set([
+    "model_change",
+    "thinking_level_change",
+    "custom",
+    "label",
+    "session_info",
+]);
+// --- Small readers ----------------------------------------------------------------
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function asHeader(value) {
+    if (!isRecord(value))
+        return null;
+    if (value.type !== "session")
+        return null;
+    if (typeof value.id !== "string" || value.id.length === 0)
+        return null;
+    const timestamp = typeof value.timestamp === "string" ? value.timestamp : "";
+    const cwd = typeof value.cwd === "string" ? value.cwd : "";
+    return {
+        type: "session",
+        ...(typeof value.version === "number" ? { version: value.version } : {}),
+        id: value.id,
+        timestamp,
+        cwd,
+    };
+}
+export function asEntry(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.type !== "string" || value.type.length === 0)
+        return null;
+    return value;
+}
+export function entryMessage(entry) {
+    if (entry.type !== "message")
+        return null;
+    return isRecord(entry.message) ? entry.message : null;
+}
+/** The visible text of a message content, hidden reasoning excluded (FR-28). */
+export function visibleText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const block of content) {
+        if (!isRecord(block))
+            continue;
+        if (block.type !== "text")
+            continue;
+        if (typeof block.text === "string")
+            parts.push(block.text);
+    }
+    return parts.join("\n");
+}
+export function toolCallBlocks(content) {
+    if (!Array.isArray(content))
+        return [];
+    const calls = [];
+    for (const block of content) {
+        if (!isRecord(block) || block.type !== "toolCall")
+            continue;
+        if (typeof block.name !== "string")
+            continue;
+        calls.push({
+            type: "toolCall",
+            id: typeof block.id === "string" ? block.id : "",
+            name: block.name,
+            arguments: isRecord(block.arguments) ? block.arguments : {},
+        });
+    }
+    return calls;
+}
+const READ_ONLY_TOOLS = new Set([
+    "read",
+    "ls",
+    "list",
+    "find",
+    "glob",
+    "grep",
+    "search",
+    "tree",
+    "fetch",
+    "webfetch",
+    "web_search",
+    "websearch",
+]);
+const MUTATING_TOOLS = new Set([
+    "write",
+    "edit",
+    "multiedit",
+    "apply_patch",
+    "applypatch",
+    "patch",
+    "create",
+    "delete",
+    "remove",
+    "move",
+    "rename",
+    "mkdir",
+    "notebookedit",
+]);
+/** Did the call change the repository? (FR-26) A shell is never assumed either way. */
+export function toolEffectFor(toolName) {
+    const name = toolName.trim().toLowerCase();
+    if (READ_ONLY_TOOLS.has(name))
+        return "read-only";
+    if (MUTATING_TOOLS.has(name))
+        return "mutating";
+    return "unknown";
+}
+/** One line, whatever the input contained. */
+export function oneLine(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+export function truncate(text, limit) {
+    return text.length <= limit ? text : `${text.slice(0, limit - 1)}…`;
+}
+export function shortArguments(argumentsText) {
+    return truncate(oneLine(argumentsText), MAX_OUTCOME_ARGUMENTS);
+}
+export function shortTitle(text) {
+    return truncate(oneLine(text), MAX_TITLE_LENGTH);
+}
+/** ISO-8601 UTC, or null when the source recorded nothing usable. */
+export function toIsoUtc(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return new Date(value).toISOString();
+    }
+    if (typeof value !== "string" || value.trim().length === 0)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : new Date(parsed).toISOString();
+}
+export function emptyUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        reasoning: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}

package/node_modules/@herbertgao/resume-from/dist/adapters/pi/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The Pi adapter's only export (FR-57). Everything Pi-specific stays inside this folder:
+ * the file layout, the `usage` requirement of C-11, and Pi's command context.
+ */
+import type { PiAdapterFactory } from "./contract.js";
+export type { PiAdapterFactory, PiSwitchContext, PiSwitchOptions, PiSwitchResult, } from "./contract.js";
+export declare const piAdapterFactory: PiAdapterFactory;

package/node_modules/@herbertgao/resume-from/dist/adapters/pi/index.js

@@ -0,0 +1,10 @@
+/**
+ * The Pi adapter's only export (FR-57). Everything Pi-specific stays inside this folder:
+ * the file layout, the `usage` requirement of C-11, and Pi's command context.
+ */
+import { createPiAdapter } from "./adapter.js";
+export const piAdapterFactory = {
+    create() {
+        return createPiAdapter();
+    },
+};

package/node_modules/@herbertgao/resume-from/dist/adapters/pi/parse.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Reading a Pi session file into the canonical vocabulary.
+ *
+ * Two rules decide everything here:
+ * - no result body crosses (FR-24). A tool result becomes one outcome line (FR-23, FR-25);
+ * - nothing is guessed. An entry type this adapter does not know is skipped and counted,
+ *   and an unparsable line makes the whole file unreadable rather than shorter.
+ */
+import type { CanonicalTurn } from "./contract.js";
+import { type PiEntry, type PiSessionHeader } from "./format.js";
+export interface ParsedSessionFile {
+    header: PiSessionHeader | null;
+    entries: PiEntry[];
+    /** True when a line was not JSON: the file was cut, or written by something else. */
+    truncated: boolean;
+}
+export interface LoadedTurns {
+    turns: CanonicalTurn[];
+    /** Entry types this adapter does not know. Visible so the preview can warn (T-PI-14). */
+    skippedEntryTypes: string[];
+    skippedCount: number;
+    /** Set when the append-only entry graph cannot produce one trustworthy active branch. */
+    unreadable: string | null;
+}
+export interface ResolvedPiEntries {
+    /** The active leaf's complete parent chain, before compaction is applied. */
+    activePath: PiEntry[];
+    /** The entries Pi would put in model context after applying its latest compaction. */
+    contextEntries: PiEntry[];
+    unreadable: string | null;
+}
+export declare function parseSessionText(text: string): ParsedSessionFile;
+/** Resolve Pi's active leaf and reproduce its compaction-aware context projection. */
+export declare function resolveActiveEntries(entries: PiEntry[]): ResolvedPiEntries;
+export declare function entriesToTurns(entries: PiEntry[]): LoadedTurns;
+/** Short human title: the session's own name, else its first user message. */
+export declare function titleFromEntries(entries: PiEntry[]): string | null;
+/** Files named by raw Pi tool inputs, before canonical credential redaction. */
+export declare function changedPathsFromEntries(entries: PiEntry[]): string[];
+/** The last timestamp the file recorded, ISO-8601 UTC, or null. */
+export declare function lastTimestamp(entries: PiEntry[]): string | null;

package/node_modules/@herbertgao/resume-from/dist/adapters/pi/parse.js

@@ -0,0 +1,371 @@
+/**
+ * Reading a Pi session file into the canonical vocabulary.
+ *
+ * Two rules decide everything here:
+ * - no result body crosses (FR-24). A tool result becomes one outcome line (FR-23, FR-25);
+ * - nothing is guessed. An entry type this adapter does not know is skipped and counted,
+ *   and an unparsable line makes the whole file unreadable rather than shorter.
+ */
+import { asEntry, asHeader, DROPPED_BODY_NOTE, entryMessage, isRecord, NON_TURN_ENTRY_TYPES, oneLine, shortArguments, toIsoUtc, toolCallBlocks, toolEffectFor, visibleText, } from "./format.js";
+import { redactSensitiveStructure, redactSensitiveText } from "./redaction.js";
+export function parseSessionText(text) {
+    const lines = text.split("\n").filter((line) => line.trim().length > 0);
+    const entries = [];
+    let header = null;
+    let truncated = false;
+    for (const [index, line] of lines.entries()) {
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            truncated = true;
+            continue;
+        }
+        if (index === 0) {
+            header = asHeader(value);
+            if (header)
+                continue;
+        }
+        const entry = asEntry(value);
+        if (entry)
+            entries.push(entry);
+        else
+            truncated = true;
+    }
+    return { header, entries, truncated };
+}
+function retainedTailEntries(compaction) {
+    if (!Array.isArray(compaction.retainedTail))
+        return [];
+    return compaction.retainedTail.flatMap((message, index) => {
+        if (!isRecord(message))
+            return [];
+        return [
+            {
+                type: "message",
+                id: `${compaction.id}:retained:${index}`,
+                parentId: null,
+                timestamp: compaction.timestamp,
+                message,
+            },
+        ];
+    });
+}
+/** Resolve Pi's active leaf and reproduce its compaction-aware context projection. */
+export function resolveActiveEntries(entries) {
+    if (entries.length === 0) {
+        return { activePath: [], contextEntries: [], unreadable: null };
+    }
+    const byId = new Map();
+    for (const entry of entries) {
+        if (typeof entry.id !== "string" || entry.id.length === 0) {
+            return {
+                activePath: [],
+                contextEntries: [],
+                unreadable: `entry ${entry.type} has no id`,
+            };
+        }
+        if (byId.has(entry.id)) {
+            return {
+                activePath: [],
+                contextEntries: [],
+                unreadable: `duplicate entry id ${entry.id}`,
+            };
+        }
+        if (entry.parentId !== null && typeof entry.parentId !== "string") {
+            return {
+                activePath: [],
+                contextEntries: [],
+                unreadable: `entry ${entry.id} has a malformed parentId`,
+            };
+        }
+        byId.set(entry.id, entry);
+    }
+    const reversed = [];
+    const visited = new Set();
+    let current = entries[entries.length - 1];
+    while (current !== undefined) {
+        if (visited.has(current.id)) {
+            return {
+                activePath: [],
+                contextEntries: [],
+                unreadable: `entry graph contains a cycle at ${current.id}`,
+            };
+        }
+        visited.add(current.id);
+        reversed.push(current);
+        if (current.parentId === null)
+            break;
+        const parent = byId.get(current.parentId);
+        if (parent === undefined) {
+            return {
+                activePath: [],
+                contextEntries: [],
+                unreadable: `entry ${current.id} refers to missing parent ${current.parentId}`,
+            };
+        }
+        current = parent;
+    }
+    const activePath = reversed.reverse();
+    let compactionIndex = -1;
+    for (let index = 0; index < activePath.length; index++) {
+        if (activePath[index]?.type === "compaction")
+            compactionIndex = index;
+    }
+    if (compactionIndex < 0) {
+        return { activePath, contextEntries: activePath, unreadable: null };
+    }
+    const compaction = activePath[compactionIndex];
+    const afterCompaction = activePath.slice(compactionIndex + 1);
+    const retainedTail = retainedTailEntries(compaction);
+    if (retainedTail.length > 0) {
+        return {
+            activePath,
+            contextEntries: [compaction, ...retainedTail, ...afterCompaction],
+            unreadable: null,
+        };
+    }
+    const firstKeptId = typeof compaction.firstKeptEntryId === "string" ? compaction.firstKeptEntryId : null;
+    const firstKeptIndex = firstKeptId === null
+        ? -1
+        : activePath.findIndex((entry, index) => index < compactionIndex && entry.id === firstKeptId);
+    const keptBefore = firstKeptIndex < 0 ? [] : activePath.slice(firstKeptIndex, compactionIndex);
+    return {
+        activePath,
+        contextEntries: [compaction, ...keptBefore, ...afterCompaction],
+        unreadable: null,
+    };
+}
+/** The result bodies of a session, keyed by tool call id. Read once, never carried. */
+function indexToolResults(entries) {
+    const results = new Map();
+    for (const entry of entries) {
+        const message = entryMessage(entry);
+        if (message?.role !== "toolResult")
+            continue;
+        const callId = typeof message.toolCallId === "string" ? message.toolCallId : "";
+        if (callId.length === 0)
+            continue;
+        results.set(callId, {
+            body: visibleText(message.content),
+            present: (typeof message.content === "string" && message.content.length > 0) ||
+                (Array.isArray(message.content) && message.content.length > 0) ||
+                isRecord(message.content),
+            isError: message.isError === true,
+        });
+    }
+    return results;
+}
+function outcomeOf(result) {
+    if (!result)
+        return { outcome: "no result recorded", bodyDropped: false };
+    if (result.body.trim().length === 0) {
+        if (result.present) {
+            return {
+                outcome: `${result.isError ? "error, result dropped" : "result recorded"} ${DROPPED_BODY_NOTE}`,
+                bodyDropped: true,
+            };
+        }
+        return {
+            outcome: result.isError ? "error" : "no output",
+            bodyDropped: false,
+        };
+    }
+    const lineCount = result.body.split("\n").length;
+    const what = result.isError ? "error" : `${lineCount} ${lineCount === 1 ? "line" : "lines"}`;
+    return { outcome: `${what} ${DROPPED_BODY_NOTE}`, bodyDropped: true };
+}
+function toolCallRecord(name, args, result) {
+    const argumentsText = JSON.stringify(redactSensitiveStructure(args));
+    const { outcome, bodyDropped } = outcomeOf(result);
+    return {
+        toolName: name,
+        argumentsText,
+        outcomeLine: redactSensitiveText(oneLine(`${name}(${shortArguments(argumentsText)}) → ${outcome}`)),
+        effect: toolEffectFor(name),
+        bodyDropped,
+        // FR-54: false when no toolResult entry existed for this call id (broken tail signal).
+        resultRecorded: result !== undefined,
+    };
+}
+function contextEntriesToTurns(entries) {
+    const results = indexToolResults(entries);
+    const turns = [];
+    const skippedEntryTypes = [];
+    let skippedCount = 0;
+    const push = (turn) => {
+        // FR-28, security: credentials pasted as message text must not cross to a different vendor.
+        // Tool-call turns carry text: "" so the condition is a no-op there (no double-redaction).
+        const text = turn.text.length > 0 ? redactSensitiveText(turn.text) : turn.text;
+        turns.push({ ...turn, text, index: turns.length });
+    };
+    const skip = (type) => {
+        skippedCount += 1;
+        if (!skippedEntryTypes.includes(type))
+            skippedEntryTypes.push(type);
+    };
+    for (const entry of entries) {
+        const timestamp = toIsoUtc(entry.timestamp);
+        if (entry.type === "compaction" || entry.type === "branch_summary") {
+            const summary = typeof entry.summary === "string" ? entry.summary : "";
+            if (summary.trim().length > 0) {
+                push({
+                    role: "agent",
+                    kind: "summary",
+                    text: summary,
+                    toolCall: null,
+                    timestamp,
+                });
+            }
+            continue;
+        }
+        if (entry.type === "message") {
+            const message = entryMessage(entry);
+            if (!message) {
+                skip("message/malformed");
+                continue;
+            }
+            if (message.role === "toolResult")
+                continue;
+            if (message.role === "user") {
+                const text = visibleText(message.content);
+                if (text.trim().length > 0) {
+                    push({
+                        role: "user",
+                        kind: "message",
+                        text,
+                        toolCall: null,
+                        timestamp,
+                    });
+                }
+                continue;
+            }
+            if (message.role === "assistant") {
+                const content = Array.isArray(message.content) ? message.content : [];
+                let buffered = "";
+                const flush = () => {
+                    if (buffered.trim().length === 0) {
+                        buffered = "";
+                        return;
+                    }
+                    push({
+                        role: "agent",
+                        kind: "message",
+                        text: buffered,
+                        toolCall: null,
+                        timestamp,
+                    });
+                    buffered = "";
+                };
+                if (!Array.isArray(message.content)) {
+                    buffered = visibleText(message.content);
+                }
+                for (const block of content) {
+                    if (!isRecord(block))
+                        continue;
+                    if (block.type === "text" && typeof block.text === "string") {
+                        buffered = buffered.length > 0 ? `${buffered}\n${block.text}` : block.text;
+                        continue;
+                    }
+                    // "thinking" blocks are hidden reasoning and never cross (FR-28, NG-7).
+                    if (block.type !== "toolCall")
+                        continue;
+                    flush();
+                    const [call] = toolCallBlocks([block]);
+                    if (!call)
+                        continue;
+                    push({
+                        role: "agent",
+                        kind: "tool-call",
+                        text: "",
+                        toolCall: toolCallRecord(call.name, call.arguments, results.get(call.id)),
+                        timestamp,
+                    });
+                }
+                flush();
+                continue;
+            }
+            skip(`message/${String(message.role)}`);
+            continue;
+        }
+        if (NON_TURN_ENTRY_TYPES.has(entry.type))
+            continue;
+        skip(entry.type);
+    }
+    return { turns, skippedEntryTypes, skippedCount };
+}
+export function entriesToTurns(entries) {
+    const resolved = resolveActiveEntries(entries);
+    if (resolved.unreadable !== null) {
+        return {
+            turns: [],
+            skippedEntryTypes: [],
+            skippedCount: 0,
+            unreadable: resolved.unreadable,
+        };
+    }
+    return {
+        ...contextEntriesToTurns(resolved.contextEntries),
+        unreadable: null,
+    };
+}
+/** Short human title: the session's own name, else its first user message. */
+export function titleFromEntries(entries) {
+    for (const entry of entries) {
+        if (entry.type !== "session_info")
+            continue;
+        if (typeof entry.name === "string" && entry.name.trim().length > 0)
+            return entry.name;
+    }
+    for (const entry of entries) {
+        const message = entryMessage(entry);
+        if (message?.role !== "user")
+            continue;
+        const text = visibleText(message.content);
+        // FR-28, security: the title flows into SourceProvenance and is shown in the selection list.
+        // A credential typed as the first message must not appear there unredacted.
+        if (text.trim().length > 0)
+            return redactSensitiveText(text);
+    }
+    return null;
+}
+/** Keys Pi's mutating tools name their target with. */
+const PATH_ARGUMENT_KEYS = ["path", "file_path", "filePath", "file", "target"];
+function changedPathOf(toolName, args) {
+    if (toolEffectFor(toolName) !== "mutating")
+        return null;
+    for (const key of PATH_ARGUMENT_KEYS) {
+        const value = args[key];
+        if (typeof value === "string" && value.trim().length > 0)
+            return value;
+    }
+    return null;
+}
+/** Files named by raw Pi tool inputs, before canonical credential redaction. */
+export function changedPathsFromEntries(entries) {
+    const paths = new Set();
+    for (const entry of entries) {
+        const message = entryMessage(entry);
+        if (message?.role !== "assistant")
+            continue;
+        for (const call of toolCallBlocks(message.content)) {
+            const path = changedPathOf(call.name, call.arguments);
+            if (path !== null)
+                paths.add(path);
+        }
+    }
+    return [...paths];
+}
+/** The last timestamp the file recorded, ISO-8601 UTC, or null. */
+export function lastTimestamp(entries) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (!entry)
+            continue;
+        const iso = toIsoUtc(entry.timestamp);
+        if (iso)
+            return iso;
+    }
+    return null;
+}

package/node_modules/@herbertgao/resume-from/dist/adapters/pi/redaction.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Credential redaction — shared implementation kept in three adapter subfolders.
+ *
+ * Files:
+ *   src/adapters/claude-code/redaction.ts
+ *   src/adapters/codex/redaction.ts
+ *   src/adapters/pi/redaction.ts
+ *
+ * These three files are byte-identical by design. A fix in one MUST be applied to all three.
+ * src/adapters/boundary.test.ts asserts byte equality and will fail if they drift.
+ *
+ * Why not a single shared module: src/adapters/contract.ts is types-only (no behaviour). A
+ * platform service would be imported as behaviour, and T-ROO-7 requires adapter-to-platform
+ * cross-module imports to go through contract.js — which can only export types, not functions.
+ */
+/** Stable replacement used for credentials that must not cross an adapter boundary. */
+export declare const REDACTED_VALUE = "[REDACTED]";
+/**
+ * Redact credentials in JSON-like tool inputs without changing the caller's value.
+ * Adapter-specific parsing stays in each adapter; this function only handles secret values.
+ */
+export declare function redactSensitiveStructure(value: unknown): unknown;
+/** Redact recognizable credentials from shell commands, headers, and unstructured arguments. */
+export declare function redactSensitiveText(text: string): string;
+/** Redact a source-recorded argument string, preserving valid JSON when it is JSON. */
+export declare function redactSensitiveArgumentsText(text: string): string;