@pi-harness/pi-harness 0.1.2 → 0.1.4

package/packages/core/src/plugins/workspace-search.ts

@@ -0,0 +1,139 @@
+import { lstat, readdir, readFile, realpath, stat } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+import type { Context } from "@deepseek-ai/cordis";
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
+
+const maxQueryLength = 256;
+const maxPathLength = 512;
+const maxFileBytes = 2 * 1024 * 1024;
+const maxFiles = 2_000;
+const maxResults = 100;
+const ignoredDirectories = new Set([".git", "node_modules", ".pi", "dist", "build"]);
+type SearchMatch = { path: string; line: number; text: string };
+type SearchReport = { query: string; path: string; matches: SearchMatch[]; matchCount: number; scannedFiles: number; skippedFiles: number; truncated: boolean };
+
+function inside(root: string, target: string): boolean {
+  const remainder = relative(root, target);
+  return remainder === "" || (remainder !== ".." && !remainder.startsWith(`..${"/"}`) && !remainder.startsWith("/"));
+}
+
+function workspacePath(root: string, requested: string): string {
+  if (requested.length > maxPathLength || requested.includes("\\"))
+    throw new Error("Workspace search path must be a relative POSIX path of at most 512 characters");
+  const target = resolve(root, requested || ".");
+  if (!inside(root, target)) throw new Error("Workspace search path must stay inside the current workspace");
+  return target;
+}
+
+async function filesUnder(target: string, root: string, files: string[]): Promise<void> {
+  if (files.length >= maxFiles) return;
+  const metadata = await lstat(target);
+  if (metadata.isSymbolicLink()) return;
+  if (metadata.isFile()) {
+    files.push(target);
+    return;
+  }
+  if (!metadata.isDirectory()) return;
+  const entries = (await readdir(target, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name));
+  for (const entry of entries) {
+    if (files.length >= maxFiles) return;
+    if (entry.isDirectory() && ignoredDirectories.has(entry.name)) continue;
+    const child = resolve(target, entry.name);
+    if (!inside(root, child)) continue;
+    await filesUnder(child, root, files);
+  }
+}
+
+export default {
+  name: "pi-workspace-search",
+  inject: ["piHarnessLaunch", "piPluginUi", "piTools"],
+  apply(context: Context) {
+    let latest: SearchReport | undefined;
+    const search = async (
+      query: string,
+      requestedPath: string | undefined,
+      caseSensitive: boolean,
+      requestedLimit: number | undefined,
+    ): Promise<SearchReport> => {
+      const normalizedQuery = query.trim();
+      if (normalizedQuery.length === 0 || normalizedQuery.length > maxQueryLength)
+        throw new Error(`Workspace search query must contain 1-${maxQueryLength} characters`);
+      const root = await realpath(context.piHarnessLaunch.cwd);
+      const target = workspacePath(root, requestedPath?.trim() ?? ".");
+      const targetMetadata = await stat(target);
+      const files: string[] = [];
+      await filesUnder(target, root, files);
+      const limit = Math.max(1, Math.min(maxResults, Math.trunc(requestedLimit ?? maxResults)));
+      const needle = caseSensitive ? normalizedQuery : normalizedQuery.toLocaleLowerCase();
+      const matches: SearchMatch[] = [];
+      let scannedFiles = 0;
+      let skippedFiles = targetMetadata.isFile() && targetMetadata.size > maxFileBytes ? 1 : 0;
+      for (const file of files) {
+        if (matches.length >= limit) break;
+        const metadata = await stat(file);
+        if (metadata.size > maxFileBytes) {
+          skippedFiles += 1;
+          continue;
+        }
+        const source = await readFile(file);
+        if (source.includes(0)) {
+          skippedFiles += 1;
+          continue;
+        }
+        scannedFiles += 1;
+        const lines = source.toString("utf8").split(/\r?\n/u);
+        for (const [index, line] of lines.entries()) {
+          if ((caseSensitive ? line : line.toLocaleLowerCase()).includes(needle)) {
+            matches.push({ path: relative(root, file), line: index + 1, text: line });
+            if (matches.length >= limit) break;
+          }
+        }
+      }
+      const report: SearchReport = {
+        query: normalizedQuery,
+        path: relative(root, target) || ".",
+        matches,
+        matchCount: matches.length,
+        scannedFiles,
+        skippedFiles,
+        truncated: matches.length >= limit && files.length > scannedFiles,
+      };
+      latest = report;
+      return report;
+    };
+    const unregisterTool = context.piTools.register(
+      defineTool({
+        name: "workspace_search",
+        label: "Search workspace",
+        description: "Search bounded UTF-8 text files in the current workspace without modifying files or invoking a shell.",
+        promptSnippet: "search the workspace for a text pattern",
+        parameters: Type.Object({
+          query: Type.String(),
+          path: Type.Optional(Type.String()),
+          caseSensitive: Type.Optional(Type.Boolean()),
+          maxResults: Type.Optional(Type.Number()),
+        }),
+        async execute(_toolCallId, params): Promise<AgentToolResult<SearchReport>> {
+          const report = await search(params.query, params.path, params.caseSensitive === true, params.maxResults);
+          return {
+            content: [{ type: "text", text: report.matches.map((match) => `${match.path}:${match.line}: ${match.text}`).join("\n") || "No matches found." }],
+            details: report,
+          };
+        },
+      }),
+    );
+    const disposePanel = context.piPluginUi.register({
+      id: "workspace-search-panel",
+      pluginId: "@pi-harness/core/plugins/workspace-search",
+      title: "Workspace Search",
+      description: "在工作区内安全检索文本，跳过依赖、构建产物和版本库目录。",
+      icon: "⌕",
+      read: () => ({ latest: latest ?? null, query: latest?.query ?? null, matchCount: latest?.matchCount ?? 0, scannedFiles: latest?.scannedFiles ?? 0 }),
+    });
+    context.effect(() => () => {
+      unregisterTool();
+      disposePanel();
+    });
+  },
+};

package/packages/core/src/plugins/yaml-validator.ts

@@ -0,0 +1,97 @@
+import { readFile, realpath, stat } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+import type { Context } from "@deepseek-ai/cordis";
+import { parseAllDocuments, isMap, isSeq, type YAMLParseError, type YAMLWarning } from "yaml";
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
+
+const maxBytes = 512 * 1024;
+type Diagnostic = { message: string; code?: string; line?: number; column?: number };
+type YamlReport = { path: string; valid: boolean; bytes: number; documents: number; rootType: string; errors: Diagnostic[]; warnings: Diagnostic[] };
+
+function workspacePath(workspace: string, requested: string): { absolute: string; relative: string } {
+  const root = resolve(workspace);
+  const target = resolve(root, requested);
+  const path = relative(root, target);
+  if (path.startsWith("..") || path.includes("/..")) throw new Error("YAML path must stay inside the current workspace");
+  return { absolute: target, relative: path || "." };
+}
+
+function diagnostic(issue: YAMLParseError | YAMLWarning): Diagnostic {
+  const position = issue.linePos?.[0];
+  return {
+    message: issue.message,
+    ...(typeof issue.code === "string" ? { code: issue.code } : {}),
+    ...(position === undefined ? {} : { line: position.line, column: position.col }),
+  };
+}
+
+function rootType(value: unknown): string {
+  if (value === null || value === undefined) return "empty";
+  if (isMap(value)) return "map";
+  if (isSeq(value)) return "seq";
+  return "scalar";
+}
+
+export default {
+  name: "pi-yaml-validator",
+  inject: ["piHarnessLaunch", "piPluginUi", "piTools"],
+  apply(context: Context) {
+    let latest: YamlReport | undefined;
+    const validate = async (requested: string): Promise<YamlReport> => {
+      const workspace = await realpath(context.piHarnessLaunch.cwd);
+      const requestedPath = workspacePath(workspace, requested);
+      const absolute = await realpath(requestedPath.absolute);
+      const location = workspacePath(workspace, absolute);
+      const metadata = await stat(location.absolute);
+      if (!metadata.isFile()) throw new Error("YAML path is not a file");
+      if (metadata.size > maxBytes) throw new Error("YAML file exceeds the 512 KiB validation limit");
+      const source = await readFile(location.absolute, "utf8");
+      const documents = parseAllDocuments(source);
+      const errors = documents.flatMap((document) => document.errors.map(diagnostic));
+      const warnings = documents.flatMap((document) => document.warnings.map(diagnostic));
+      const report: YamlReport = {
+        path: location.relative,
+        valid: errors.length === 0,
+        bytes: metadata.size,
+        documents: documents.length,
+        rootType: rootType(documents[0]?.contents),
+        errors,
+        warnings,
+      };
+      latest = report;
+      return report;
+    };
+    const unregisterTool = context.piTools.register(
+      defineTool({
+        name: "yaml_validate",
+        label: "YAML validate",
+        description: "Parse a YAML file in the current workspace and report line-aware errors without modifying it.",
+        promptSnippet: "validate a YAML file and report syntax diagnostics",
+        parameters: Type.Object({ path: Type.String({ description: "YAML path relative to the workspace" }) }),
+        async execute(_toolCallId, params): Promise<AgentToolResult<YamlReport>> {
+          const report = await validate(params.path);
+          const summary = report.valid ? `YAML is valid (${report.documents} document(s)).` : `YAML is invalid with ${report.errors.length} error(s).`;
+          return {
+            content: [
+              { type: "text", text: `${summary}\n${report.errors.map((issue) => `${issue.line ?? "?"}:${issue.column ?? "?"} ${issue.message}`).join("\n")}` },
+            ],
+            details: report,
+          };
+        },
+      }),
+    );
+    const disposePanel = context.piPluginUi.register({
+      id: "yaml-validator-panel",
+      pluginId: "@pi-harness/core/plugins/yaml-validator",
+      title: "YAML Validator",
+      description: "只读解析工作区 YAML，并展示行列级语法诊断。",
+      icon: "⌁",
+      read: () => ({ latest: latest ?? null, maxBytes }),
+    });
+    context.effect(() => () => {
+      unregisterTool();
+      disposePanel();
+    });
+  },
+};

package/packages/core/src/profile.ts

@@ -2,6 +2,8 @@ import { access } from "node:fs/promises";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
+export const BUILTIN_PROFILES = ["default", "development"] as const;
+
 export interface ResolveProfileConfigOptions {
   profile?: string;
   configPath?: string;
@@ -25,6 +27,7 @@ export async function resolveProfileConfig(_options: ResolveProfileConfigOptions
   try {
     await access(configPath);
   } catch (cause) {
+    if (options.configPath === undefined) throw new Error(`Pi Harness profile config does not exist or is not readable: ${configPath}; built-in profiles are ${BUILTIN_PROFILES.join(", ")}`, { cause });
     throw new Error(`Pi Harness profile config does not exist or is not readable: ${configPath}`, { cause });
   }
   return configPath;

package/packages/core/src/runtime.ts

@@ -12,6 +12,7 @@ export class PiRuntimeDisposedError extends Error {
 export class PiRuntime implements PiRuntimeService {
   readonly sessionRuntime: AgentSessionRuntime;
   #disposed = false;
+  #sessionDisposed = false;
 
   constructor(sessionRuntime: AgentSessionRuntime) {
     this.sessionRuntime = sessionRuntime;
@@ -23,17 +24,23 @@ export class PiRuntime implements PiRuntimeService {
 
   async prompt(text: string): Promise<void> {
     if (this.#disposed) throw new PiRuntimeDisposedError();
-    await this.sessionRuntime.session.prompt(text);
+    await this.session.prompt(text);
   }
 
   async abort(): Promise<void> {
-    if (this.#disposed) return;
-    await this.sessionRuntime.session.abort();
+    if (this.#sessionDisposed) return;
+    await this.session.abort();
   }
 
   async dispose(): Promise<void> {
     if (this.#disposed) return;
     this.#disposed = true;
-    await this.sessionRuntime.dispose();
+    try {
+      // Settle an in-flight turn first so its tool results are persisted before session_shutdown runs.
+      if (!this.session.isIdle) await this.session.abort();
+    } finally {
+      this.#sessionDisposed = true;
+      await this.sessionRuntime.dispose();
+    }
   }
 }

package/packages/core/src/services.ts

@@ -1,11 +1,23 @@
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
 import type { Context } from "@deepseek-ai/cordis";
-import type { AgentSession, AgentSessionEvent, AgentSessionRuntime, AgentSessionServices, ExtensionError, SessionManager, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type {
+  AgentSession,
+  AgentSessionEvent,
+  AgentSessionRuntime,
+  AgentSessionServices,
+  ExtensionError,
+  SessionManager,
+  ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
 
 export interface PiHarnessLaunch {
   readonly cwd: string;
+  readonly cwdUrl?: string;
   readonly agentDir: string;
+  readonly configPath?: string;
   readonly args: readonly string[];
   requestExit(code: number): void;
 }
@@ -29,6 +41,17 @@ export interface PiSessionService {
   readonly manager: SessionManager;
 }
 
+export interface PiMcpServerSnapshot {
+  readonly id: string;
+  readonly command: readonly string[];
+  readonly status: string;
+  readonly startedAt: number;
+}
+
+export interface PiMcpService {
+  snapshot(): { readonly servers: readonly PiMcpServerSnapshot[] };
+}
+
 export interface PiRuntimeService {
   readonly session: AgentSession;
   readonly sessionRuntime: AgentSessionRuntime;
@@ -37,6 +60,17 @@ export interface PiRuntimeService {
   dispose(): Promise<void>;
 }
 
+export interface PiTelemetryEvent {
+  readonly name: string;
+  readonly properties?: Readonly<Record<string, unknown>>;
+}
+
+export interface PiTelemetryService {
+  readonly enabled: false;
+  send(event: PiTelemetryEvent): { blocked: true; name: string };
+  snapshot(): { blocked: number; names: readonly string[] };
+}
+
 export interface PiToolsSnapshot {
   readonly names: string[];
   readonly customTools: ToolDefinition[];
@@ -46,6 +80,8 @@ export interface PiToolsLease extends PiToolsSnapshot {
   release(): void;
 }
 
+const PI_BUILTIN_TOOL_NAMES = ["read", "bash", "powershell", "edit", "write", "grep", "find", "ls"];
+
 export class PiToolRegistry {
   readonly #names: string[];
   readonly #customTools = new Map<string, ToolDefinition>();
@@ -58,9 +94,10 @@ export class PiToolRegistry {
   register(tool: ToolDefinition): () => void {
     if (this.#leases > 0) throw new Error(`Pi tool registry is leased by pi-runtime; declare a Cordis injection that activates ${tool.name} before pi-runtime`);
     if (this.#names.includes(tool.name) || this.#customTools.has(tool.name)) throw new Error(`Pi tool is already registered: ${tool.name}`);
+    if (PI_BUILTIN_TOOL_NAMES.includes(tool.name)) throw new Error(`Pi tool name is reserved by a built-in tool: ${tool.name}`);
     this.#customTools.set(tool.name, tool);
     return () => {
-      this.#customTools.delete(tool.name);
+      if (this.#customTools.get(tool.name) === tool) this.#customTools.delete(tool.name);
     };
   }
 
@@ -82,6 +119,70 @@ export class PiToolRegistry {
   }
 }
 
+export interface PiPluginPanel {
+  readonly id: string;
+  readonly pluginId: string;
+  readonly title: string;
+  readonly description?: string;
+  readonly icon?: string;
+  readonly visible?: () => boolean | Promise<boolean>;
+  readonly read: () => unknown;
+}
+
+export interface PiPluginPanelSnapshot {
+  readonly id: string;
+  readonly pluginId: string;
+  readonly title: string;
+  readonly description?: string;
+  readonly icon?: string;
+  readonly data?: unknown;
+  readonly error?: string;
+}
+
+export class PiPluginUiRegistry {
+  readonly #panels = new Map<string, PiPluginPanel>();
+
+  register(panel: PiPluginPanel): () => void {
+    if (panel.id.trim() === "" || panel.pluginId.trim() === "" || panel.title.trim() === "")
+      throw new Error("Plugin UI panel id, pluginId, and title are required");
+    if (this.#panels.has(panel.id)) throw new Error(`Plugin UI panel is already registered: ${panel.id}`);
+    this.#panels.set(panel.id, panel);
+    let active = true;
+    return () => {
+      if (!active) return;
+      active = false;
+      if (this.#panels.get(panel.id) === panel) this.#panels.delete(panel.id);
+    };
+  }
+
+  async snapshot(): Promise<readonly PiPluginPanelSnapshot[]> {
+    const snapshots: PiPluginPanelSnapshot[] = [];
+    for (const panel of this.#panels.values()) {
+      if (panel.visible !== undefined && !(await panel.visible())) continue;
+      try {
+        snapshots.push({
+          id: panel.id,
+          pluginId: panel.pluginId,
+          title: panel.title,
+          ...(panel.description === undefined ? {} : { description: panel.description }),
+          ...(panel.icon === undefined ? {} : { icon: panel.icon }),
+          data: await panel.read(),
+        });
+      } catch (error) {
+        snapshots.push({
+          id: panel.id,
+          pluginId: panel.pluginId,
+          title: panel.title,
+          ...(panel.description === undefined ? {} : { description: panel.description }),
+          ...(panel.icon === undefined ? {} : { icon: panel.icon }),
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+    return snapshots;
+  }
+}
+
 declare module "@deepseek-ai/cordis" {
   interface Context {
     piHarnessLaunch: PiHarnessLaunch;
@@ -89,17 +190,23 @@ declare module "@deepseek-ai/cordis" {
     piModels: PiModelsService;
     piResources: PiResourcesService;
     piSession: PiSessionService;
+    piMcp: PiMcpService;
     piTools: PiToolRegistry;
+    piPluginUi: PiPluginUiRegistry;
     piRuntime: PiRuntimeService;
+    piTelemetry: PiTelemetryService;
   }
 
   interface Events {
     "pi/session-event"(event: AgentSessionEvent): void;
     "pi/extension-error"(error: ExtensionError): void;
+    "pi/telemetry"(event: PiTelemetryEvent): void;
   }
 }
 
 export function provideLaunchContext(context: Context, launch: PiHarnessLaunch): () => void {
-  const value: PiHarnessLaunch = Object.freeze({ ...launch, args: Object.freeze([...launch.args]) });
+  if (!isAbsolute(launch.cwd)) throw new Error(`Pi Harness launch cwd must be an absolute path: ${launch.cwd}`);
+  if (!isAbsolute(launch.agentDir)) throw new Error(`Pi Harness agent directory must be an absolute path: ${launch.agentDir}`);
+  const value: PiHarnessLaunch = Object.freeze({ ...launch, cwdUrl: pathToFileURL(launch.cwd).href, args: Object.freeze([...launch.args]) });
   return context.provide("piHarnessLaunch", value);
 }

package/packages/core/src/stdio.ts

@@ -2,14 +2,29 @@ import type { Context } from "@deepseek-ai/cordis";
 import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import type { PiHarnessLaunch, PiRuntimeService } from "./services.js";
 
+export class PiHarnessStdioCancelledError extends Error {
+  override readonly name = "PiHarnessStdioCancelledError";
+
+  constructor() {
+    super("Prompt input was cancelled");
+  }
+}
+
 export interface PiHarnessStdio {
   readPrompt(): Promise<string>;
   writeOutput(text: string): void;
   writeError(text: string): void;
+  /** Resolve once everything written so far has reached the underlying stream. */
+  flush?(): Promise<void>;
 }
 
 export interface PiHarnessApplication {
-  run(): Promise<number>;
+  /**
+   * Run the application surface to completion.
+   *
+   * @param signal - aborted when the host is shutting down; a surface that can block must unwind on it.
+   */
+  run(signal?: AbortSignal): Promise<number>;
 }
 
 declare module "@deepseek-ai/cordis" {
@@ -25,22 +40,43 @@ export function provideStdioContext(context: Context, stdio: PiHarnessStdio): ()
 
 function promptFromArgs(args: readonly string[]): string | undefined {
   if (args.length === 0) return undefined;
+  if (args[0] === "--") return args.length === 1 ? undefined : args.slice(1).join(" ");
   if (args[0] === "--prompt") {
     const prompt = args[1];
     if (prompt === undefined) throw new Error("--prompt requires a value");
     if (args.length > 2) throw new Error("--prompt accepts exactly one value");
     return prompt;
   }
-  if (args[0]?.startsWith("--prompt=")) return args[0].slice("--prompt=".length);
-  if (args.some((arg) => arg.startsWith("-"))) throw new Error(`Unknown stdio option: ${args.find((arg) => arg.startsWith("-")) ?? ""}`);
+  if (args[0]?.startsWith("--prompt=")) {
+    if (args.length > 1) throw new Error("--prompt accepts exactly one value");
+    return args[0].slice("--prompt=".length);
+  }
+  const option = args[0];
+  if (option !== undefined && option.startsWith("-")) throw new Error(`Unknown stdio option: ${option}; pass -- before a prompt that starts with a dash`);
   return args.join(" ");
 }
 
+const PROMPT_CANCELLED_EXIT_CODE = 130;
+const TOOL_ARGUMENT_SUMMARY_LIMIT = 120;
+
+function summarizeToolArguments(args: unknown): string {
+  let text: string;
+  try {
+    text = typeof args === "string" ? args : JSON.stringify(args) ?? "";
+  } catch {
+    return "";
+  }
+  const line = text.replace(/\s+/g, " ").trim();
+  return line.length > TOOL_ARGUMENT_SUMMARY_LIMIT ? `${line.slice(0, TOOL_ARGUMENT_SUMMARY_LIMIT)}...` : line;
+}
+
 export class StdioApplication implements PiHarnessApplication {
   readonly #runtime: PiRuntimeService;
   readonly #launch: PiHarnessLaunch;
   readonly #stdio: PiHarnessStdio;
   #running = false;
+  #pendingSeparator = false;
+  #wroteOutput = false;
 
   constructor(runtime: PiRuntimeService, launch: PiHarnessLaunch, stdio: PiHarnessStdio) {
     this.#runtime = runtime;
@@ -50,17 +86,42 @@ export class StdioApplication implements PiHarnessApplication {
 
   writeSessionEvent(event: AgentSessionEvent): void {
     if (!this.#running) return;
-    if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") this.#stdio.writeOutput(event.assistantMessageEvent.delta);
+    if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+      if (this.#pendingSeparator) {
+        this.#pendingSeparator = false;
+        this.#stdio.writeOutput("\n");
+      }
+      this.#wroteOutput = true;
+      this.#stdio.writeOutput(event.assistantMessageEvent.delta);
+      return;
+    }
+    if (event.type === "tool_execution_start") {
+      if (this.#wroteOutput) this.#pendingSeparator = true;
+      this.#stdio.writeError(`> ${event.toolName} ${summarizeToolArguments(event.args)}\n`);
+      return;
+    }
+    if (event.type === "tool_execution_end") {
+      const result = event.result as { isError?: boolean } | undefined;
+      if (result?.isError === true) this.#stdio.writeError(`! ${event.toolName} failed\n`);
+      return;
+    }
+    if (event.type === "auto_retry_start") this.#stdio.writeError(`Retrying after ${event.errorMessage} (attempt ${event.attempt}/${event.maxAttempts})\n`);
   }
 
-  async run(): Promise<number> {
+  async run(signal?: AbortSignal): Promise<number> {
     if (this.#running) throw new Error("stdio application is already running");
     this.#running = true;
+    const onAbort = () => {
+      void this.#runtime.abort().catch(() => {});
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
     try {
+      if (signal?.aborted === true) return PROMPT_CANCELLED_EXIT_CODE;
       let prompt: string;
       try {
-        prompt = promptFromArgs(this.#launch.args) ?? await this.#stdio.readPrompt();
+        prompt = promptFromArgs(this.#launch.args) ?? (await this.#stdio.readPrompt());
       } catch (error) {
+        if (error instanceof PiHarnessStdioCancelledError) return PROMPT_CANCELLED_EXIT_CODE;
         this.#stdio.writeError(`${error instanceof Error ? error.message : String(error)}\n`);
         return 2;
       }
@@ -74,15 +135,24 @@ export class StdioApplication implements PiHarnessApplication {
         this.#stdio.writeError(`${error instanceof Error ? error.message : String(error)}\n`);
         return 1;
       }
-      const lastMessage = this.#runtime.session.messages.at(-1);
-      if (lastMessage?.role === "assistant" && (lastMessage.stopReason === "error" || lastMessage.stopReason === "aborted")) {
-        this.#stdio.writeError(`${lastMessage.errorMessage ?? `Request ${lastMessage.stopReason}`}\n`);
+      const lastAssistantMessage = this.#runtime.session.messages.findLast((message) => message.role === "assistant");
+      const stopReason = lastAssistantMessage?.stopReason;
+      if (stopReason === "error" || stopReason === "aborted" || stopReason === "length") {
+        if (this.#wroteOutput) this.#stdio.writeOutput("\n");
+        this.#stdio.writeError(`${lastAssistantMessage?.errorMessage ?? (stopReason === "length" ? "Response was truncated by the model's output limit" : `Request ${stopReason}`)}\n`);
+        return 1;
+      }
+      if (!this.#wroteOutput) {
+        this.#stdio.writeError("The agent produced no output\n");
         return 1;
       }
       this.#stdio.writeOutput("\n");
       return 0;
     } finally {
+      signal?.removeEventListener("abort", onAbort);
       this.#running = false;
+      this.#pendingSeparator = false;
+      await this.#stdio.flush?.();
     }
   }
 }