@chendpoc/pi-memory 0.2.4 → 0.3.2

package/dist/store/writePath.d.ts

@@ -0,0 +1,20 @@
+import type { MarkdownMemoryBackend } from "./backend.js";
+import type { ParsedEntry, ResolvedMemory, StoreMemoryEntry } from "./types.js";
+export type WritePathDeps = {
+    backend: MarkdownMemoryBackend;
+    memoryFile: string;
+    agentDir: string;
+    maxLines: number;
+    createId: () => string;
+    newAutoFilePath: () => string;
+    readResolvedUnlocked: () => Promise<ResolvedMemory>;
+};
+export declare function normalizeEntry(entry: StoreMemoryEntry, createId: () => string): StoreMemoryEntry;
+/** Ground Truth ingress gate: normalize → redact → skip if empty. */
+export declare function prepareEntryForWrite(entry: StoreMemoryEntry, createId: () => string): StoreMemoryEntry | null;
+export declare function tryAppendUnlocked(deps: WritePathDeps, entry: StoreMemoryEntry): Promise<boolean>;
+/** Physical write only; entry must already pass prepareEntryForWrite. */
+export declare function appendOneUnlocked(deps: WritePathDeps, entry: StoreMemoryEntry): Promise<void>;
+export declare function appendIfAbsentUnlocked(deps: WritePathDeps, entry: StoreMemoryEntry): Promise<boolean>;
+export declare function appendToOverflowUnlocked(deps: WritePathDeps, entry: StoreMemoryEntry, main: string): Promise<void>;
+export declare function rewriteEntriesUnlocked(deps: WritePathDeps, entries: ParsedEntry[]): Promise<void>;

package/dist/store/writePath.js

@@ -0,0 +1,123 @@
+import { isEmptyAfterRedaction, redactText } from "../redaction/redactText.js";
+import { pathBasename } from "../utils/fs.js";
+import { debugMemory } from "../utils/debugLog.js";
+import { formatTimestamp } from "../utils/time.js";
+import { countLines, formatEntryLine, formatSectionHeader } from "./markdown/format.js";
+import { insertEntryIntoMarkdown } from "./markdown/insert.js";
+import { MEMORY_SECTIONS } from "./types.js";
+export function normalizeEntry(entry, createId) {
+    return {
+        ...entry,
+        id: entry.id || createId(),
+        timestamp: entry.timestamp || formatTimestamp(),
+    };
+}
+/** Ground Truth ingress gate: normalize → redact → skip if empty. */
+export function prepareEntryForWrite(entry, createId) {
+    const normalized = normalizeEntry(entry, createId);
+    try {
+        const result = redactText(normalized.content);
+        const prepared = { ...normalized, content: result.text };
+        if (isEmptyAfterRedaction(prepared.content)) {
+            debugMemory("write", "write_skipped", {
+                reason: "redaction_empty",
+                entryId: prepared.id,
+            });
+            return null;
+        }
+        if (result.mutated) {
+            debugMemory("write", "write_redacted", {
+                hitCount: result.hitCount,
+                secretHits: result.secretHits,
+                piiHits: result.piiHits,
+                entryId: prepared.id,
+                policyVersion: result.policyVersion,
+            });
+        }
+        return prepared;
+    }
+    catch {
+        debugMemory("write", "write_skipped", {
+            reason: "redaction_error",
+            entryId: normalized.id,
+        });
+        return null;
+    }
+}
+export async function tryAppendUnlocked(deps, entry) {
+    const prepared = prepareEntryForWrite(entry, deps.createId);
+    if (!prepared)
+        return false;
+    await appendOneUnlocked(deps, prepared);
+    return true;
+}
+/** Physical write only; entry must already pass prepareEntryForWrite. */
+export async function appendOneUnlocked(deps, entry) {
+    const main = await deps.backend.readText(deps.memoryFile);
+    if (countLines(main) >= deps.maxLines) {
+        await appendToOverflowUnlocked(deps, entry, main);
+        return;
+    }
+    const next = insertEntryIntoMarkdown(main, entry);
+    if (countLines(next) > deps.maxLines) {
+        await appendToOverflowUnlocked(deps, entry, main);
+        return;
+    }
+    await deps.backend.writeText(deps.memoryFile, next);
+}
+export async function appendIfAbsentUnlocked(deps, entry) {
+    const prepared = prepareEntryForWrite(entry, deps.createId);
+    if (!prepared)
+        return false;
+    const resolved = await deps.readResolvedUnlocked();
+    const exists = resolved.entries.some((item) => item.section === prepared.section && item.content.trim() === prepared.content.trim());
+    if (exists)
+        return false;
+    await appendOneUnlocked(deps, prepared);
+    return true;
+}
+export async function appendToOverflowUnlocked(deps, entry, main) {
+    const autoFiles = await deps.backend.listAutoFiles(deps.agentDir);
+    let targetName = autoFiles.at(-1);
+    let targetPath = targetName
+        ? deps.backend.autoFilePath(deps.agentDir, targetName)
+        : deps.newAutoFilePath();
+    if (!targetName) {
+        targetName = pathBasename(targetPath);
+        await deps.backend.writeText(targetPath, `${formatSectionHeader(entry.section)}\n\n`);
+    }
+    let overflowContent = await deps.backend.readText(targetPath);
+    const line = formatEntryLine(entry);
+    overflowContent = overflowContent.trimEnd() + `\n${line}\n`;
+    await deps.backend.writeText(targetPath, overflowContent);
+    const pointer = `- (overflow) → ${targetName}`;
+    if (!main.includes(pointer)) {
+        const withPointer = `${main.trimEnd()}\n${pointer}\n`;
+        await deps.backend.writeText(deps.memoryFile, withPointer);
+    }
+}
+export async function rewriteEntriesUnlocked(deps, entries) {
+    const grouped = new Map();
+    for (const section of MEMORY_SECTIONS)
+        grouped.set(section, []);
+    for (const entry of entries) {
+        grouped.get(entry.section)?.push(entry);
+    }
+    const lines = [];
+    for (const section of MEMORY_SECTIONS) {
+        lines.push(formatSectionHeader(section), "");
+        for (const entry of grouped.get(section) ?? []) {
+            lines.push(formatEntryLine({
+                id: entry.id,
+                section: entry.section,
+                content: entry.content,
+                userAuthored: entry.userAuthored,
+                timestamp: entry.timestamp,
+            }));
+        }
+        lines.push("");
+    }
+    await deps.backend.writeText(deps.memoryFile, `${lines.join("\n").trimEnd()}\n`);
+    const autoFiles = await deps.backend.listAutoFiles(deps.agentDir);
+    await Promise.all(autoFiles.map((fileName) => deps.backend.deleteAutoFile(deps.backend.autoFilePath(deps.agentDir, fileName))));
+}

package/dist/ui/memoryStatusWidget.d.ts

@@ -1,19 +1,15 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { Component, TUI } from "@earendil-works/pi-tui";
-import type { MemoryStatusReport } from "../cli/status.js";
+import type { Component } from "@earendil-works/pi-tui";
+import { type MemoryStatusReport } from "../status/index.js";
 export type MemoryStatusWidgetState = {
     report: MemoryStatusReport;
     expanded: boolean;
 };
 export declare class MemoryStatusWidget implements Component {
     private readonly theme;
-    private state;
-    private cachedWidth?;
-    private cachedLines?;
-    private version;
-    private cachedVersion;
+    private readonly state;
     constructor(theme: Theme, state: MemoryStatusWidgetState);
     invalidate(): void;
     render(width: number): string[];
 }
-export declare function createMemoryStatusWidget(_tui: TUI, theme: Theme, state: MemoryStatusWidgetState): MemoryStatusWidget;
+export declare function createMemoryStatusWidget(theme: Theme, state: MemoryStatusWidgetState): MemoryStatusWidget;

package/dist/ui/memoryStatusWidget.js

@@ -1,5 +1,5 @@
 import { truncateToWidth } from "@earendil-works/pi-tui";
-import { formatMemoryStatusSummary, formatMemoryStatusTuiLines, piStatusPalette, } from "../cli/status.js";
+import { MEMORY_STATUS_COLLAPSE_HINT, MEMORY_STATUS_EXPAND_HINT, formatMemoryStatusSummary, formatMemoryStatusTuiLines, piStatusPalette, } from "../status/index.js";
 function formatHeader(theme, width) {
     const title = theme.fg("accent", theme.bold("pi-memory status"));
     const fill = Math.max(0, width - title.length - 2);
@@ -10,26 +10,17 @@ function formatHeader(theme, width) {
 export class MemoryStatusWidget {
     theme;
     state;
-    cachedWidth;
-    cachedLines;
-    version = 0;
-    cachedVersion = -1;
     constructor(theme, state) {
         this.theme = theme;
         this.state = state;
     }
-    invalidate() {
-        this.cachedLines = undefined;
-    }
+    invalidate() { }
     render(width) {
-        if (this.cachedLines && this.cachedWidth === width && this.cachedVersion === this.version) {
-            return this.cachedLines;
-        }
         const palette = piStatusPalette(this.theme);
         const lines = [];
         if (!this.state.expanded) {
             const summary = formatMemoryStatusSummary(this.state.report, palette, (text) => this.theme.fg("accent", text));
-            const hint = this.theme.fg("dim", " (/memory-status to expand)");
+            const hint = this.theme.fg("dim", MEMORY_STATUS_EXPAND_HINT);
             lines.push(truncateToWidth(`${summary}${hint}`, width));
         }
         else {
@@ -37,14 +28,11 @@ export class MemoryStatusWidget {
             for (const line of formatMemoryStatusTuiLines(this.state.report, palette, this.theme)) {
                 lines.push(truncateToWidth(`  ${line}`, width));
             }
-            lines.push(truncateToWidth(this.theme.fg("dim", "  /memory-status to collapse · /memory-status hide to dismiss"), width));
+            lines.push(truncateToWidth(this.theme.fg("dim", MEMORY_STATUS_COLLAPSE_HINT), width));
         }
-        this.cachedLines = lines;
-        this.cachedWidth = width;
-        this.cachedVersion = this.version;
         return lines;
     }
 }
-export function createMemoryStatusWidget(_tui, theme, state) {
+export function createMemoryStatusWidget(theme, state) {
     return new MemoryStatusWidget(theme, state);
 }

package/dist/utils/async.d.ts

@@ -0,0 +1,11 @@
+export declare const PREFLIGHT_ABORTED_MESSAGE = "aborted";
+export declare const PREFLIGHT_TIMEOUT_MESSAGE = "preflight timeout";
+/** Throw when `signal` is already aborted (matches legacy preflight fail-fast). */
+export declare function throwIfAborted(signal?: AbortSignal, message?: string): void;
+/**
+ * Merge a budget timeout with an optional caller `AbortSignal`.
+ * Uses Node built-ins: AbortSignal.timeout + AbortSignal.any.
+ */
+export declare function mergeAbortSignals(timeoutMs: number, userSignal?: AbortSignal): AbortSignal;
+/** Preflight budget + extension cancel. Alias for {@link mergeAbortSignals}. */
+export declare function preflightAbortSignal(budgetMs: number, userSignal?: AbortSignal): AbortSignal;

package/dist/utils/async.js

@@ -0,0 +1,24 @@
+export const PREFLIGHT_ABORTED_MESSAGE = "aborted";
+export const PREFLIGHT_TIMEOUT_MESSAGE = "preflight timeout";
+/** Throw when `signal` is already aborted (matches legacy preflight fail-fast). */
+export function throwIfAborted(signal, message = PREFLIGHT_ABORTED_MESSAGE) {
+    if (signal?.aborted) {
+        throw new Error(message);
+    }
+}
+/**
+ * Merge a budget timeout with an optional caller `AbortSignal`.
+ * Uses Node built-ins: AbortSignal.timeout + AbortSignal.any.
+ */
+export function mergeAbortSignals(timeoutMs, userSignal) {
+    throwIfAborted(userSignal);
+    if (timeoutMs <= 0) {
+        throw new Error(PREFLIGHT_TIMEOUT_MESSAGE);
+    }
+    const timeout = AbortSignal.timeout(timeoutMs);
+    return userSignal ? AbortSignal.any([timeout, userSignal]) : timeout;
+}
+/** Preflight budget + extension cancel. Alias for {@link mergeAbortSignals}. */
+export function preflightAbortSignal(budgetMs, userSignal) {
+    return mergeAbortSignals(budgetMs, userSignal);
+}

package/dist/utils/index.d.ts

@@ -1,7 +1,11 @@
 export { getPlatform, isMacOS, isUnixLike, isWindows, type PiMemoryPlatform, } from "./platform.js";
-export { CONFIG_DIR_NAME, defaultMemoryAgentDir, defaultPiConfigDir, defaultPiMemoryEnvFile, defaultPiLogsDir, expandHomePath, getAgentDir, mkdirOptions, secureDirMode, secureFileMode, } from "./paths.js";
+export { CONFIG_DIR_NAME, defaultConsolidateErrLogPath, defaultConsolidateLogPath, defaultMemoryAgentDir, defaultPiConfigDir, defaultPiMemoryEnvFile, defaultPiLogsDir, expandHomePath, getAgentDir, mkdirOptions, resolveConsolidateErrLogPath, resolveConsolidateLogPath, resolvePiLogsDir, secureDirMode, secureFileMode, } from "./paths.js";
 export { appendText, canRead, ensureDir, ensureDirSync, ensureFile, isENOENT, joinPath, listDir, pathBasename, pathDirname, pathExists, readText, readTextRequired, removeFile, writeText, } from "./fs.js";
 export { cleanupSocketFiles, removeSocketFile, secureSocketPath } from "./socket.js";
 export { debugMemory, isMemoryDebugEnabled } from "./debugLog.js";
 export { daysSince, epochTimestamp, formatLocalDate, formatTimestamp, now, nowMs, parseTime, remainingMs, type TimeInput, } from "./time.js";
 export { buildConsolidateCliArgs, buildMaintenanceCliArgs, defaultConsolidateSchedulerPaths, formatConsolidateCronLine, formatMaintenanceCronLine, getConsolidateSchedulerKind, getConsolidateTemplateNames, type ConsolidateCliInvocation, type ConsolidateSchedulerKind, type ConsolidateSchedulerPaths, type ConsolidateTemplateName, } from "./scheduler.js";
+export { mergeAbortSignals, preflightAbortSignal, PREFLIGHT_ABORTED_MESSAGE, PREFLIGHT_TIMEOUT_MESSAGE, throwIfAborted, } from "./async.js";
+export { JsonlFramer, parseJsonlLine, serializeJsonlFrame } from "./jsonl.js";
+export { entryDedupeKey, stripPrivateMemory, stripPrivateMemoryFromMessages } from "./memory/index.js";
+export { isSubagentSession, readParentSession } from "./session/index.js";

package/dist/utils/index.js

@@ -1,7 +1,11 @@
 export { getPlatform, isMacOS, isUnixLike, isWindows, } from "./platform.js";
-export { CONFIG_DIR_NAME, defaultMemoryAgentDir, defaultPiConfigDir, defaultPiMemoryEnvFile, defaultPiLogsDir, expandHomePath, getAgentDir, mkdirOptions, secureDirMode, secureFileMode, } from "./paths.js";
+export { CONFIG_DIR_NAME, defaultConsolidateErrLogPath, defaultConsolidateLogPath, defaultMemoryAgentDir, defaultPiConfigDir, defaultPiMemoryEnvFile, defaultPiLogsDir, expandHomePath, getAgentDir, mkdirOptions, resolveConsolidateErrLogPath, resolveConsolidateLogPath, resolvePiLogsDir, secureDirMode, secureFileMode, } from "./paths.js";
 export { appendText, canRead, ensureDir, ensureDirSync, ensureFile, isENOENT, joinPath, listDir, pathBasename, pathDirname, pathExists, readText, readTextRequired, removeFile, writeText, } from "./fs.js";
 export { cleanupSocketFiles, removeSocketFile, secureSocketPath } from "./socket.js";
 export { debugMemory, isMemoryDebugEnabled } from "./debugLog.js";
 export { daysSince, epochTimestamp, formatLocalDate, formatTimestamp, now, nowMs, parseTime, remainingMs, } from "./time.js";
 export { buildConsolidateCliArgs, buildMaintenanceCliArgs, defaultConsolidateSchedulerPaths, formatConsolidateCronLine, formatMaintenanceCronLine, getConsolidateSchedulerKind, getConsolidateTemplateNames, } from "./scheduler.js";
+export { mergeAbortSignals, preflightAbortSignal, PREFLIGHT_ABORTED_MESSAGE, PREFLIGHT_TIMEOUT_MESSAGE, throwIfAborted, } from "./async.js";
+export { JsonlFramer, parseJsonlLine, serializeJsonlFrame } from "./jsonl.js";
+export { entryDedupeKey, stripPrivateMemory, stripPrivateMemoryFromMessages } from "./memory/index.js";
+export { isSubagentSession, readParentSession } from "./session/index.js";

package/dist/{ipc/jsonlFramer.d.ts → utils/jsonl.d.ts}

@@ -1,4 +1,4 @@
-/** Incremental JSONL (one JSON object per line) framing for UDS IPC. */
+/** Incremental JSONL (one JSON object per line) framing for UDS IPC and queue files. */
 export declare class JsonlFramer {
     private buffer;
     push(chunk: string): string[];

package/dist/{ipc/jsonlFramer.js → utils/jsonl.js}

@@ -1,4 +1,4 @@
-/** Incremental JSONL (one JSON object per line) framing for UDS IPC. */
+/** Incremental JSONL (one JSON object per line) framing for UDS IPC and queue files. */
 export class JsonlFramer {
     buffer = "";
     push(chunk) {

package/dist/utils/memory/index.d.ts

@@ -0,0 +1,10 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+/** Stable dedupe key for memory entries (section + trimmed content). */
+export declare function entryDedupeKey(entry: {
+    section: string;
+    content: string;
+}): string;
+/** Remove `<private_memory>...</private_memory>` blocks from plain text. */
+export declare function stripPrivateMemory(text: string): string;
+/** Strip private memory tags from user message text blocks before compaction or drain. */
+export declare function stripPrivateMemoryFromMessages(messages: AgentMessage[]): AgentMessage[];

package/dist/utils/memory/index.js

@@ -0,0 +1,43 @@
+import { PRIVATE_MEMORY_CLOSE, PRIVATE_MEMORY_OPEN } from "../../constants/preflight.js";
+/** Stable dedupe key for memory entries (section + trimmed content). */
+export function entryDedupeKey(entry) {
+    return `${entry.section}\0${entry.content.trim()}`;
+}
+/** Remove `<private_memory>...</private_memory>` blocks from plain text. */
+export function stripPrivateMemory(text) {
+    let s = text;
+    for (;;) {
+        const i = s.indexOf(PRIVATE_MEMORY_OPEN);
+        if (i < 0)
+            return s;
+        const rel = s.indexOf(PRIVATE_MEMORY_CLOSE, i);
+        if (rel < 0)
+            return s;
+        let end = rel + PRIVATE_MEMORY_CLOSE.length;
+        while (end < s.length && /[\n\r \t]/.test(s[end]))
+            end++;
+        let start = i;
+        while (start > 0 && /[ \t]/.test(s[start - 1]))
+            start--;
+        if (start > 0 && s[start - 1] === "\n") {
+            start--;
+            if (start > 0 && s[start - 1] === "\r")
+                start--;
+        }
+        s = s.slice(0, start) + s.slice(end);
+    }
+}
+/** Strip private memory tags from user message text blocks before compaction or drain. */
+export function stripPrivateMemoryFromMessages(messages) {
+    return messages.map((message) => {
+        if (message.role !== "user")
+            return message;
+        if (typeof message.content === "string") {
+            return { ...message, content: stripPrivateMemory(message.content) };
+        }
+        return {
+            ...message,
+            content: message.content.map((block) => block.type === "text" ? { ...block, text: stripPrivateMemory(block.text) } : block),
+        };
+    });
+}

package/dist/utils/paths.d.ts

@@ -8,8 +8,12 @@ export declare function defaultPiConfigDir(): string;
 export declare function defaultMemoryAgentDir(): string;
 /** pi-memory config: ~/.pi/agent/pi-memory.env */
 export declare function defaultPiMemoryEnvFile(): string;
+/** Maintenance logs live under the memory agent dir (`<agentDir>/logs`). */
+export declare function resolvePiLogsDir(agentDir: string): string;
 export declare function defaultPiLogsDir(): string;
+export declare function resolveConsolidateLogPath(agentDir: string): string;
 export declare function defaultConsolidateLogPath(): string;
+export declare function resolveConsolidateErrLogPath(agentDir: string): string;
 export declare function defaultConsolidateErrLogPath(): string;
 /** Directory mode for agent / socket parent dirs (Unix only; ignored on Windows). */
 export declare function secureDirMode(): number | undefined;

package/dist/utils/paths.js

@@ -27,14 +27,24 @@ export function defaultMemoryAgentDir() {
 export function defaultPiMemoryEnvFile() {
     return join(getAgentDir(), PI_MEMORY_ENV_FILE_NAME);
 }
+/** Maintenance logs live under the memory agent dir (`<agentDir>/logs`). */
+export function resolvePiLogsDir(agentDir) {
+    return join(agentDir, PI_LOGS_SUBDIR);
+}
 export function defaultPiLogsDir() {
-    return join(defaultPiConfigDir(), PI_LOGS_SUBDIR);
+    return resolvePiLogsDir(defaultMemoryAgentDir());
+}
+export function resolveConsolidateLogPath(agentDir) {
+    return join(resolvePiLogsDir(agentDir), CONSOLIDATE_LOG_FILE);
 }
 export function defaultConsolidateLogPath() {
-    return join(defaultPiLogsDir(), CONSOLIDATE_LOG_FILE);
+    return resolveConsolidateLogPath(defaultMemoryAgentDir());
+}
+export function resolveConsolidateErrLogPath(agentDir) {
+    return join(resolvePiLogsDir(agentDir), CONSOLIDATE_ERR_LOG_FILE);
 }
 export function defaultConsolidateErrLogPath() {
-    return join(defaultPiLogsDir(), CONSOLIDATE_ERR_LOG_FILE);
+    return resolveConsolidateErrLogPath(defaultMemoryAgentDir());
 }
 /** Directory mode for agent / socket parent dirs (Unix only; ignored on Windows). */
 export function secureDirMode() {

package/dist/utils/scheduler.d.ts

@@ -10,7 +10,7 @@ export type ConsolidateSchedulerPaths = {
     stdoutLog: string;
     stderrLog: string;
 };
-export declare function defaultConsolidateSchedulerPaths(): ConsolidateSchedulerPaths;
+export declare function defaultConsolidateSchedulerPaths(agentDir?: string): ConsolidateSchedulerPaths;
 export type ConsolidateCliInvocation = {
     nodePath: string;
     cliPath: string;

package/dist/utils/scheduler.js

@@ -1,5 +1,5 @@
 import { LAUNCHD_LABEL, SCHEDULER_TEMPLATE_FILES, SCHTASKS_TASK_NAME, } from "../constants/paths.js";
-import { defaultConsolidateErrLogPath, defaultConsolidateLogPath, defaultMemoryAgentDir, defaultPiMemoryEnvFile, defaultPiLogsDir, } from "./paths.js";
+import { defaultMemoryAgentDir, defaultPiMemoryEnvFile, resolveConsolidateErrLogPath, resolveConsolidateLogPath, resolvePiLogsDir, } from "./paths.js";
 import { getPlatform, isMacOS, isWindows } from "./platform.js";
 /** Recommended OS scheduler for daily consolidate on this platform. */
 export function getConsolidateSchedulerKind(platform = getPlatform()) {
@@ -9,13 +9,13 @@ export function getConsolidateSchedulerKind(platform = getPlatform()) {
         return "schtasks";
     return "crontab";
 }
-export function defaultConsolidateSchedulerPaths() {
+export function defaultConsolidateSchedulerPaths(agentDir = defaultMemoryAgentDir()) {
     return {
-        agentDir: defaultMemoryAgentDir(),
+        agentDir,
         envFile: defaultPiMemoryEnvFile(),
-        logsDir: defaultPiLogsDir(),
-        stdoutLog: defaultConsolidateLogPath(),
-        stderrLog: defaultConsolidateErrLogPath(),
+        logsDir: resolvePiLogsDir(agentDir),
+        stdoutLog: resolveConsolidateLogPath(agentDir),
+        stderrLog: resolveConsolidateErrLogPath(agentDir),
     };
 }
 /** argv for `pi-memory maintenance` (OS scheduler / wrapper scripts). */

package/dist/{preflight/session.d.ts → utils/session/index.d.ts}

@@ -1,2 +1,3 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+export declare function readParentSession(header: Record<string, unknown> | null): string | undefined;
 export declare function isSubagentSession(ctx: ExtensionContext): boolean;

package/dist/{preflight/session.js → utils/session/index.js}

@@ -1,5 +1,8 @@
+export function readParentSession(header) {
+    const parent = header?.parentSession ?? header?.parent_session;
+    return typeof parent === "string" && parent.trim().length > 0 ? parent.trim() : undefined;
+}
 export function isSubagentSession(ctx) {
     const header = ctx.sessionManager.getHeader();
-    const parent = header?.parentSession ?? header?.parent_session;
-    return typeof parent === "string" && parent.trim().length > 0;
+    return readParentSession(header) !== undefined;
 }