@oh-my-pi/pi-coding-agent 7.0.0 → 8.0.1

package/src/{core → session}/agent-session.ts

@@ -28,23 +28,21 @@ import type {
 import { isContextOverflow, modelsAreEqual, supportsXhigh } from "@oh-my-pi/pi-ai";
 import { abortableSleep, logger } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
-import type { Rule } from "../capability/rule";
-import { getAgentDbPath } from "../config";
-import { theme } from "../modes/interactive/theme/theme";
-import ttsrInterruptTemplate from "../prompts/system/ttsr-interrupt.md" with { type: "text" };
-import { type BashResult, executeBash as executeBashCommand } from "./bash-executor";
+import type { Rule } from "$c/capability/rule";
+import { getAgentDbPath } from "$c/config";
+import type { ModelRegistry } from "$c/config/model-registry";
+import { parseModelString } from "$c/config/model-resolver";
 import {
-	type CompactionResult,
-	calculateContextTokens,
-	collectEntriesForBranchSummary,
-	compact,
-	estimateTokens,
-	generateBranchSummary,
-	prepareCompaction,
-	shouldCompact,
-} from "./compaction/index";
-import type { LoadedCustomCommand } from "./custom-commands/index";
-import { exportSessionToHtml } from "./export-html/index";
+	expandPromptTemplate,
+	type PromptTemplate,
+	parseCommandArgs,
+	renderPromptTemplate,
+} from "$c/config/prompt-templates";
+import type { SettingsManager, SkillsSettings } from "$c/config/settings-manager";
+import { type BashResult, executeBash as executeBashCommand } from "$c/exec/bash-executor";
+import { exportSessionToHtml } from "$c/export/html/index";
+import type { TtsrManager } from "$c/export/ttsr";
+import type { LoadedCustomCommand } from "$c/extensibility/custom-commands/index";
 import type {
 	ExtensionCommandContext,
 	ExtensionRunner,
@@ -56,10 +54,31 @@ import type {
 	TreePreparation,
 	TurnEndEvent,
 	TurnStartEvent,
-} from "./extensions";
-import type { CompactOptions, ContextUsage } from "./extensions/types";
-import { extractFileMentions, generateFileMentionMessages } from "./file-mentions";
-import type { HookCommandContext } from "./hooks/types";
+} from "$c/extensibility/extensions";
+import type { CompactOptions, ContextUsage } from "$c/extensibility/extensions/types";
+import type { HookCommandContext } from "$c/extensibility/hooks/types";
+import type { Skill, SkillWarning } from "$c/extensibility/skills";
+import { expandSlashCommand, type FileSlashCommand } from "$c/extensibility/slash-commands";
+import { executePython as executePythonCommand, type PythonResult } from "$c/ipy/executor";
+import { theme } from "$c/modes/theme/theme";
+import { normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "$c/patch";
+import ttsrInterruptTemplate from "$c/prompts/system/ttsr-interrupt.md" with { type: "text" };
+import { closeAllConnections } from "$c/ssh/connection-manager";
+import { unmountAll } from "$c/ssh/sshfs-mount";
+import { outputMeta } from "$c/tools/output-meta";
+import { resolveToCwd } from "$c/tools/path-utils";
+import type { TodoItem } from "$c/tools/todo-write";
+import { extractFileMentions, generateFileMentionMessages } from "$c/utils/file-mentions";
+import {
+	type CompactionResult,
+	calculateContextTokens,
+	collectEntriesForBranchSummary,
+	compact,
+	estimateTokens,
+	generateBranchSummary,
+	prepareCompaction,
+	shouldCompact,
+} from "./compaction/index";
 import {
 	type BashExecutionMessage,
 	type BranchSummaryMessage,
@@ -71,20 +90,7 @@ import {
 	type PythonExecutionMessage,
 	pythonExecutionToText,
 } from "./messages";
-import type { ModelRegistry } from "./model-registry";
-import { parseModelString } from "./model-resolver";
-import { expandPromptTemplate, type PromptTemplate, parseCommandArgs, renderPromptTemplate } from "./prompt-templates";
-import { executePython as executePythonCommand, type PythonResult } from "./python-executor";
 import type { BranchSummaryEntry, CompactionEntry, NewSessionOptions, SessionManager } from "./session-manager";
-import type { SettingsManager, SkillsSettings } from "./settings-manager";
-import type { Skill, SkillWarning } from "./skills";
-import { expandSlashCommand, type FileSlashCommand } from "./slash-commands";
-import { closeAllConnections } from "./ssh/connection-manager";
-import { unmountAll } from "./ssh/sshfs-mount";
-import { normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "./tools/patch";
-import { resolveToCwd } from "./tools/path-utils";
-import type { TodoItem } from "./tools/todo-write";
-import type { TtsrManager } from "./ttsr";
 
 /** Session-specific events that extend the core AgentEvent */
 export type AgentSessionEvent =
@@ -587,7 +593,7 @@ export class AgentSession {
 
 		const args = toolCall.arguments;
 		if (!args || typeof args !== "object" || Array.isArray(args)) return;
-		if ("oldText" in args || "newText" in args) return;
+		if ("old_text" in args || "new_text" in args) return;
 
 		const path = typeof args.path === "string" ? args.path : undefined;
 		if (!path) return;
@@ -632,7 +638,7 @@ export class AgentSession {
 
 		const args = toolCall.arguments;
 		if (!args || typeof args !== "object" || Array.isArray(args)) return;
-		if ("oldText" in args || "newText" in args) return;
+		if ("old_text" in args || "new_text" in args) return;
 
 		const path = typeof args.path === "string" ? args.path : undefined;
 		const diff = typeof args.diff === "string" ? args.diff : undefined;
@@ -2597,6 +2603,7 @@ export class AgentSession {
 	 * Used by executeBash and by extensions that handle bash execution themselves.
 	 */
 	recordBashResult(command: string, result: BashResult, options?: { excludeFromContext?: boolean }): void {
+		const meta = outputMeta().truncationFromSummary(result, { direction: "tail" }).get();
 		const bashMessage: BashExecutionMessage = {
 			role: "bashExecution",
 			command,
@@ -2604,7 +2611,7 @@ export class AgentSession {
 			exitCode: result.exitCode,
 			cancelled: result.cancelled,
 			truncated: result.truncated,
-			fullOutputPath: result.fullOutputPath,
+			meta,
 			timestamp: Date.now(),
 			excludeFromContext: options?.excludeFromContext,
 		};
@@ -2701,6 +2708,7 @@ export class AgentSession {
 	 * Record a Python execution result in session history.
 	 */
 	recordPythonResult(code: string, result: PythonResult, options?: { excludeFromContext?: boolean }): void {
+		const meta = outputMeta().truncationFromSummary(result, { direction: "tail" }).get();
 		const pythonMessage: PythonExecutionMessage = {
 			role: "pythonExecution",
 			code,
@@ -2708,7 +2716,7 @@ export class AgentSession {
 			exitCode: result.exitCode,
 			cancelled: result.cancelled,
 			truncated: result.truncated,
-			fullOutputPath: result.fullOutputPath,
+			meta,
 			timestamp: Date.now(),
 			excludeFromContext: options?.excludeFromContext,
 		};

package/src/{core → session}/agent-storage.ts

@@ -2,9 +2,9 @@ import { Database } from "bun:sqlite";
 import { chmodSync, existsSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
-import { getAgentDbPath } from "../config";
+import { getAgentDbPath } from "$c/config";
+import type { Settings } from "$c/config/settings-manager";
 import type { AuthCredential } from "./auth-storage";
-import type { Settings } from "./settings-manager";
 
 /** Prepared SQLite statement type from bun:sqlite */
 type Statement = ReturnType<Database["prepare"]>;

package/src/session/artifacts.ts

@@ -0,0 +1,110 @@
+/**
+ * Session-scoped artifact storage for truncated tool outputs.
+ *
+ * Artifacts are stored in a directory alongside the session file,
+ * accessible via artifact:// URLs or the $ARTIFACTS environment variable.
+ */
+
+import { mkdir, readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+/**
+ * Manages artifact storage for a session.
+ *
+ * Artifacts are stored with sequential IDs in the session's artifact directory.
+ * The directory is created lazily on first write.
+ */
+export class ArtifactManager {
+	#nextId = 0;
+	readonly #dir: string;
+	#dirCreated = false;
+
+	/**
+	 * @param sessionFile Path to the session .jsonl file
+	 */
+	constructor(sessionFile: string) {
+		// Artifact directory is session file path without .jsonl extension
+		this.#dir = sessionFile.slice(0, -6);
+	}
+
+	/**
+	 * Artifact directory path.
+	 * Directory may not exist until first artifact is saved.
+	 */
+	get dir(): string {
+		return this.#dir;
+	}
+
+	async #ensureDir(): Promise<void> {
+		if (!this.#dirCreated) {
+			await mkdir(this.#dir, { recursive: true });
+			this.#dirCreated = true;
+		}
+	}
+
+	/**
+	 * Atomically allocate next artifact ID.
+	 * IDs are sequential within the session.
+	 */
+	allocateId(): number {
+		return this.#nextId++;
+	}
+
+	/**
+	 * Allocate a new artifact path and ID without writing content.
+	 *
+	 * @param toolType Tool name for file extension (e.g., "bash", "fetch")
+	 */
+	async allocatePath(toolType: string): Promise<{ id: string; path: string }> {
+		await this.#ensureDir();
+		const id = String(this.allocateId());
+		const filename = `${id}.${toolType}.txt`;
+		return { id, path: join(this.#dir, filename) };
+	}
+
+	/**
+	 * Save content as an artifact and return the artifact ID.
+	 *
+	 * @param content Full content to save
+	 * @param toolType Tool name for file extension (e.g., "bash", "fetch")
+	 * @returns Artifact ID (numeric string)
+	 */
+	async save(content: string, toolType: string): Promise<string> {
+		const { id, path } = await this.allocatePath(toolType);
+		await Bun.write(path, content);
+		return id;
+	}
+
+	/**
+	 * Check if an artifact exists.
+	 * @param id Artifact ID (numeric string)
+	 */
+	async exists(id: string): Promise<boolean> {
+		const files = await this.listFiles();
+		return files.some((f) => f.startsWith(`${id}.`));
+	}
+
+	/**
+	 * List all artifact files in the directory.
+	 * Returns empty array if directory doesn't exist.
+	 */
+	async listFiles(): Promise<string[]> {
+		try {
+			return await readdir(this.#dir);
+		} catch {
+			return [];
+		}
+	}
+
+	/**
+	 * Get the full path to an artifact file.
+	 * Returns null if artifact doesn't exist.
+	 *
+	 * @param id Artifact ID (numeric string)
+	 */
+	async getPath(id: string): Promise<string | null> {
+		const files = await this.listFiles();
+		const match = files.find((f) => f.startsWith(`${id}.`));
+		return match ? join(this.#dir, match) : null;
+	}
+}

package/src/{core → session}/auth-storage.ts

@@ -33,7 +33,7 @@ import {
 	zaiUsageProvider,
 } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
-import { getAgentDbPath, getAuthPath } from "../config";
+import { getAgentDbPath, getAuthPath } from "$c/config";
 import { AgentStorage } from "./agent-storage";
 import { migrateJsonStorage } from "./storage-migration";
 

package/src/{core → session}/compaction/branch-summarization.ts

@@ -8,16 +8,16 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
-import branchSummaryPrompt from "../../prompts/compaction/branch-summary.md" with { type: "text" };
-import branchSummaryPreamble from "../../prompts/compaction/branch-summary-preamble.md" with { type: "text" };
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import branchSummaryPrompt from "$c/prompts/compaction/branch-summary.md" with { type: "text" };
+import branchSummaryPreamble from "$c/prompts/compaction/branch-summary-preamble.md" with { type: "text" };
 import {
 	convertToLlm,
 	createBranchSummaryMessage,
 	createCompactionSummaryMessage,
 	createCustomMessage,
-} from "../messages";
-import { renderPromptTemplate } from "../prompt-templates";
-import type { ReadonlySessionManager, SessionEntry } from "../session-manager";
+} from "$c/session/messages";
+import type { ReadonlySessionManager, SessionEntry } from "$c/session/session-manager";
 import { estimateTokens } from "./compaction";
 import {
 	computeFileLists,

package/src/{core → session}/compaction/compaction.ts

@@ -8,12 +8,12 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage, Model, Usage } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
-import compactionSummaryPrompt from "../../prompts/compaction/compaction-summary.md" with { type: "text" };
-import compactionTurnPrefixPrompt from "../../prompts/compaction/compaction-turn-prefix.md" with { type: "text" };
-import compactionUpdateSummaryPrompt from "../../prompts/compaction/compaction-update-summary.md" with { type: "text" };
-import { convertToLlm, createBranchSummaryMessage, createCustomMessage } from "../messages";
-import { renderPromptTemplate } from "../prompt-templates";
-import type { CompactionEntry, SessionEntry } from "../session-manager";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import compactionSummaryPrompt from "$c/prompts/compaction/compaction-summary.md" with { type: "text" };
+import compactionTurnPrefixPrompt from "$c/prompts/compaction/compaction-turn-prefix.md" with { type: "text" };
+import compactionUpdateSummaryPrompt from "$c/prompts/compaction/compaction-update-summary.md" with { type: "text" };
+import { convertToLlm, createBranchSummaryMessage, createCustomMessage } from "$c/session/messages";
+import type { CompactionEntry, SessionEntry } from "$c/session/session-manager";
 import {
 	computeFileLists,
 	createFileOps,

package/src/{core → session}/compaction/utils.ts

@@ -4,9 +4,9 @@
 
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { Message } from "@oh-my-pi/pi-ai";
-import fileOperationsTemplate from "../../prompts/system/file-operations.md" with { type: "text" };
-import summarizationSystemPrompt from "../../prompts/system/summarization-system.md" with { type: "text" };
-import { renderPromptTemplate } from "../prompt-templates";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import fileOperationsTemplate from "$c/prompts/system/file-operations.md" with { type: "text" };
+import summarizationSystemPrompt from "$c/prompts/system/summarization-system.md" with { type: "text" };
 
 // ============================================================================
 // File Operation Tracking

package/src/{core → session}/history-storage.ts

@@ -2,7 +2,7 @@ import { Database } from "bun:sqlite";
 import { mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
-import { getAgentDir } from "../config";
+import { getAgentDir } from "$c/config";
 
 export interface HistoryEntry {
 	id: number;

package/src/{core → session}/messages.ts

@@ -7,6 +7,8 @@
 
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Message, TextContent } from "@oh-my-pi/pi-ai";
+import type { OutputMeta } from "$c/tools/output-meta";
+import { formatOutputNotice } from "$c/tools/output-meta";
 
 export const COMPACTION_SUMMARY_PREFIX = `The conversation history before this point was compacted into the following summary:
 
@@ -33,7 +35,7 @@ export interface BashExecutionMessage {
 	exitCode: number | undefined;
 	cancelled: boolean;
 	truncated: boolean;
-	fullOutputPath?: string;
+	meta?: OutputMeta;
 	timestamp: number;
 	/** If true, this message is excluded from LLM context (!! prefix) */
 	excludeFromContext?: boolean;
@@ -50,7 +52,7 @@ export interface PythonExecutionMessage {
 	exitCode: number | undefined;
 	cancelled: boolean;
 	truncated: boolean;
-	fullOutputPath?: string;
+	meta?: OutputMeta;
 	timestamp: number;
 	/** If true, this message is excluded from LLM context ($$ prefix) */
 	excludeFromContext?: boolean;
@@ -136,9 +138,7 @@ export function bashExecutionToText(msg: BashExecutionMessage): string {
 	} else if (msg.exitCode !== null && msg.exitCode !== undefined && msg.exitCode !== 0) {
 		text += `\n\nCommand exited with code ${msg.exitCode}`;
 	}
-	if (msg.truncated && msg.fullOutputPath) {
-		text += `\n\n[Output truncated. Full output: ${msg.fullOutputPath}]`;
-	}
+	text += formatOutputNotice(msg.meta);
 	return text;
 }
 
@@ -157,9 +157,7 @@ export function pythonExecutionToText(msg: PythonExecutionMessage): string {
 	} else if (msg.exitCode !== null && msg.exitCode !== undefined && msg.exitCode !== 0) {
 		text += `\n\nExecution failed with code ${msg.exitCode}`;
 	}
-	if (msg.truncated && msg.fullOutputPath) {
-		text += `\n\n[Output truncated. Full output: ${msg.fullOutputPath}]`;
-	}
+	text += formatOutputNotice(msg.meta);
 	return text;
 }
 

package/src/{core → session}/session-manager.ts

@@ -3,8 +3,8 @@ import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Message, TextContent, Usage } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
 import { nanoid } from "nanoid";
-import { getAgentDir as getDefaultAgentDir } from "../config";
-import { resizeImage } from "../utils/image-resize";
+import { getAgentDir as getDefaultAgentDir } from "$c/config";
+import { resizeImage } from "$c/utils/image-resize";
 import {
 	type BashExecutionMessage,
 	type CustomMessage,

package/src/{core → session}/storage-migration.ts

@@ -5,10 +5,10 @@
  */
 
 import { logger } from "@oh-my-pi/pi-utils";
-import { getAgentDbPath } from "../config";
+import { getAgentDbPath } from "$c/config";
+import type { Settings } from "$c/config/settings-manager";
 import { AgentStorage } from "./agent-storage";
 import type { AuthCredential, AuthCredentialEntry, AuthStorageData } from "./auth-storage";
-import type { Settings } from "./settings-manager";
 
 /** Paths configuration for the storage migration process. */
 type MigrationPaths = {

package/src/session/streaming-output.ts

@@ -0,0 +1,177 @@
+import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { DEFAULT_MAX_BYTES } from "$c/tools/truncate";
+
+export interface OutputSummary {
+	output: string;
+	truncated: boolean;
+	totalLines: number;
+	totalBytes: number;
+	outputLines: number;
+	outputBytes: number;
+	/** Artifact ID for internal URL access (artifact://<id>) when truncated */
+	artifactId?: string;
+}
+
+export interface OutputSinkOptions {
+	artifactPath?: string;
+	artifactId?: string;
+	spillThreshold?: number;
+	onChunk?: (chunk: string) => void;
+}
+
+function countNewlines(text: string): number {
+	let count = 0;
+	for (let i = 0; i < text.length; i++) {
+		if (text.charCodeAt(i) === 10) count += 1;
+	}
+	return count;
+}
+
+function countLines(text: string): number {
+	if (text.length === 0) return 0;
+	return countNewlines(text) + 1;
+}
+
+function truncateStringToBytesFromEnd(text: string, maxBytes: number): { text: string; bytes: number } {
+	const buf = Buffer.from(text, "utf-8");
+	if (buf.length <= maxBytes) {
+		return { text, bytes: buf.length };
+	}
+
+	let start = buf.length - maxBytes;
+	while (start < buf.length && (buf[start] & 0xc0) === 0x80) {
+		start++;
+	}
+
+	const sliced = buf.subarray(start).toString("utf-8");
+	return { text: sliced, bytes: Buffer.byteLength(sliced, "utf-8") };
+}
+
+/**
+ * Line-buffered output sink with file spill support.
+ *
+ * Uses a single string buffer with line position tracking.
+ * When memory limit exceeded, spills ~half to file in one batch operation.
+ */
+export class OutputSink {
+	#buffer = "";
+	#bufferBytes = 0;
+	#totalLines = 0;
+	#totalBytes = 0;
+	#sawData = false;
+	#truncated = false;
+	#file?: {
+		path: string;
+		artifactId?: string;
+		sink: Bun.FileSink;
+	};
+	readonly #artifactPath?: string;
+	readonly #artifactId?: string;
+	readonly #spillThreshold: number;
+	readonly #onChunk?: (chunk: string) => void;
+
+	constructor(options?: OutputSinkOptions) {
+		const { artifactPath, artifactId, spillThreshold = DEFAULT_MAX_BYTES, onChunk } = options ?? {};
+
+		this.#artifactPath = artifactPath;
+		this.#artifactId = artifactId;
+		this.#spillThreshold = spillThreshold;
+		this.#onChunk = onChunk;
+	}
+
+	async #pushSanitized(data: string): Promise<void> {
+		this.#onChunk?.(data);
+
+		const dataBytes = Buffer.byteLength(data, "utf-8");
+		this.#totalBytes += dataBytes;
+		if (data.length > 0) {
+			this.#sawData = true;
+			this.#totalLines += countNewlines(data);
+		}
+
+		const bufferOverflow = this.#bufferBytes + dataBytes > this.#spillThreshold;
+		const overflow = this.#file || bufferOverflow;
+		const sink = overflow ? await this.#fileSink() : null;
+
+		this.#buffer += data;
+		this.#bufferBytes += dataBytes;
+		await sink?.write(data);
+
+		if (bufferOverflow) {
+			this.#truncated = true;
+			const trimmed = truncateStringToBytesFromEnd(this.#buffer, this.#spillThreshold);
+			this.#buffer = trimmed.text;
+			this.#bufferBytes = trimmed.bytes;
+		}
+		if (this.#file) {
+			this.#truncated = true;
+		}
+	}
+
+	async #fileSink(): Promise<Bun.FileSink | null> {
+		if (!this.#artifactPath) return null;
+		if (!this.#file) {
+			try {
+				this.#file = {
+					path: this.#artifactPath,
+					artifactId: this.#artifactId,
+					sink: Bun.file(this.#artifactPath).writer(),
+				};
+				await this.#file.sink.write(this.#buffer);
+			} catch {
+				try {
+					await this.#file?.sink?.end();
+				} catch {}
+				this.#file = undefined;
+				return null;
+			}
+		}
+		return this.#file.sink;
+	}
+
+	async push(chunk: string): Promise<void> {
+		chunk = sanitizeText(chunk);
+		await this.#pushSanitized(chunk);
+	}
+
+	createInput(): WritableStream<Uint8Array | string> {
+		const dec = new TextDecoder("utf-8", { ignoreBOM: true });
+		const finalize = async () => {
+			await this.push(dec.decode());
+		};
+
+		return new WritableStream<Uint8Array | string>({
+			write: async (chunk) => {
+				if (typeof chunk === "string") {
+					await this.push(chunk);
+				} else {
+					await this.push(dec.decode(chunk, { stream: true }));
+				}
+			},
+			close: finalize,
+			abort: finalize,
+		});
+	}
+
+	async dump(notice?: string): Promise<OutputSummary> {
+		const noticeLine = notice ? `[${notice}]\n` : "";
+		const outputLines = countLines(this.#buffer);
+		const outputBytes = this.#bufferBytes;
+		const totalLines = this.#sawData ? this.#totalLines + 1 : 0;
+		const totalBytes = this.#totalBytes;
+
+		if (this.#file) {
+			await this.#file.sink.end();
+		}
+
+		return {
+			output: `${noticeLine}${this.#buffer}`,
+			truncated: this.#truncated,
+			totalLines,
+			totalBytes,
+			outputLines,
+			outputBytes,
+			artifactId: this.#file?.artifactId,
+		};
+	}
+}

package/src/{core/ssh → ssh}/connection-manager.ts

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
-import { CONFIG_DIR_NAME } from "../../config";
+import { CONFIG_DIR_NAME } from "$c/config";
 
 export interface SSHConnectionTarget {
 	name: string;

package/src/{core/ssh → ssh}/ssh-executor.ts

@@ -1,5 +1,5 @@
 import { cspawn, logger, ptree } from "@oh-my-pi/pi-utils";
-import { OutputSink } from "../streaming-output";
+import { OutputSink } from "$c/session/streaming-output";
 import { buildRemoteCommand, ensureConnection, ensureHostInfo, type SSHConnectionTarget } from "./connection-manager";
 import { hasSshfs, mountRemote } from "./sshfs-mount";
 
@@ -14,6 +14,9 @@ export interface SSHExecutorOptions {
 	remotePath?: string;
 	/** Wrap commands in a POSIX shell for compat mode */
 	compatEnabled?: boolean;
+	/** Artifact path/id for full output storage */
+	artifactPath?: string;
+	artifactId?: string;
 }
 
 export interface SSHResult {
@@ -25,8 +28,16 @@ export interface SSHResult {
 	cancelled: boolean;
 	/** Whether the output was truncated */
 	truncated: boolean;
-	/** Path to temp file containing full output (if output exceeded truncation threshold) */
-	fullOutputPath?: string;
+	/** Total number of lines in the output stream */
+	totalLines: number;
+	/** Total number of bytes in the output stream */
+	totalBytes: number;
+	/** Number of lines included in the output text */
+	outputLines: number;
+	/** Number of bytes included in the output text */
+	outputBytes: number;
+	/** Artifact ID if full output was saved to artifact storage */
+	artifactId?: string;
 }
 
 function quoteForCompatShell(command: string): string {
@@ -70,7 +81,11 @@ export async function executeSSH(
 		timeout: options?.timeout,
 	});
 
-	const sink = new OutputSink({ onChunk: options?.onChunk });
+	const sink = new OutputSink({
+		onChunk: options?.onChunk,
+		artifactPath: options?.artifactPath,
+		artifactId: options?.artifactId,
+	});
 
 	await Promise.allSettled([child.stdout.pipeTo(sink.createInput()), child.stderr.pipeTo(sink.createInput())]).catch(
 		() => {},

package/src/{core/ssh → ssh}/sshfs-mount.ts

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
-import { CONFIG_DIR_NAME } from "../../config";
+import { CONFIG_DIR_NAME } from "$c/config";
 import { getControlDir, getControlPathTemplate, type SSHConnectionTarget } from "./connection-manager";
 
 const REMOTE_DIR = join(homedir(), CONFIG_DIR_NAME, "remote");