@pi-ohm/subagents 0.6.4-dev.22244904817.1.e83c930 → 0.6.4-dev.22264411679.1.2aa3a99

package/README.md

@@ -360,7 +360,8 @@ Additional hardening behaviors:
 
 Persistence details:
 
-- default snapshot path: `${PI_CONFIG_DIR|PI_CODING_AGENT_DIR|PI_AGENT_DIR|~/.pi/agent}/ohm.subagents.tasks.json`
+- default snapshot path: `${XDG_DATA_HOME:-~/.local/share}/pi/agent/ohm.subagents.tasks.json`
+- override snapshot path: `OHM_SUBAGENTS_TASK_PERSIST_PATH=/abs/path/ohm.subagents.tasks.json`
 - retention window is configurable via `OHM_SUBAGENTS_TASK_RETENTION_MS` (positive integer ms)
 - per-task structured event timeline cap is configurable via `OHM_SUBAGENTS_TASK_MAX_EVENTS`
   (default `120`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-ohm/subagents",
-  "version": "0.6.4-dev.22244904817.1.e83c930",
+  "version": "0.6.4-dev.22264411679.1.2aa3a99",
   "homepage": "https://github.com/pi-ohm/pi-ohm/tree/dev/packages/subagents#readme",
   "repository": {
     "type": "git",
@@ -19,11 +19,11 @@
     "provenance": true
   },
   "dependencies": {
-    "@mariozechner/pi-coding-agent": "catalog:pi",
-    "@pi-ohm/config": "0.6.4-dev.22244904817.1.e83c930",
-    "@pi-ohm/tui": "0.6.4-dev.22244904817.1.e83c930",
-    "better-result": "catalog:",
-    "zod": "catalog:"
+    "@mariozechner/pi-coding-agent": "^0.52.0",
+    "@pi-ohm/config": "0.6.4-dev.22264411679.1.2aa3a99",
+    "@pi-ohm/tui": "0.6.4-dev.22264411679.1.2aa3a99",
+    "better-result": "^2.6.0",
+    "zod": "^4"
   },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": "*",

package/src/tools/primary.ts

@@ -296,6 +296,10 @@ function toPrimaryToolCallText(subagent: OhmSubagentDefinition, params: unknown)
 }
 
 function toResultText(result: AgentToolResult<unknown>): string {
+  if (isTaskToolResultDetails(result.details)) {
+    return formatTaskToolResult(result.details, false);
+  }
+
   const textBlocks = result.content.filter(
     (part): part is { readonly type: "text"; readonly text: string } => part.type === "text",
   );
@@ -303,10 +307,6 @@ function toResultText(result: AgentToolResult<unknown>): string {
   const joined = textBlocks.map((part) => part.text).join("\n\n");
   if (joined.length > 0) return joined;
 
-  if (isTaskToolResultDetails(result.details)) {
-    return formatTaskToolResult(result.details, false);
-  }
-
   return "primary subagent tool result unavailable";
 }
 

package/src/tools/task/contracts.ts

@@ -62,6 +62,8 @@ export interface TaskToolResultDetails {
   readonly output_truncated?: boolean;
   readonly output_total_chars?: number;
   readonly output_returned_chars?: number;
+  readonly updated_at_epoch_ms?: number;
+  readonly ended_at_epoch_ms?: number;
   readonly backend: string;
   readonly provider?: string;
   readonly model?: string;

package/src/tools/task/defaults.test.ts

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveDefaultTaskPersistencePath } from "./defaults";
+import { defineTest } from "./test-fixtures";
+
+const ORIGINAL_XDG_DATA_HOME = process.env.XDG_DATA_HOME;
+const ORIGINAL_TASK_PERSIST_PATH = process.env.OHM_SUBAGENTS_TASK_PERSIST_PATH;
+
+function setEnv(name: "XDG_DATA_HOME" | "OHM_SUBAGENTS_TASK_PERSIST_PATH", value?: string): void {
+  if (value === undefined) {
+    delete process.env[name];
+    return;
+  }
+
+  process.env[name] = value;
+}
+
+function restoreEnv(): void {
+  setEnv("XDG_DATA_HOME", ORIGINAL_XDG_DATA_HOME);
+  setEnv("OHM_SUBAGENTS_TASK_PERSIST_PATH", ORIGINAL_TASK_PERSIST_PATH);
+}
+
+defineTest("resolveDefaultTaskPersistencePath uses explicit override when configured", () => {
+  try {
+    setEnv("XDG_DATA_HOME", "/tmp/xdg-data");
+    setEnv("OHM_SUBAGENTS_TASK_PERSIST_PATH", "/tmp/custom/subagent-tasks.json");
+
+    const resolved = resolveDefaultTaskPersistencePath();
+    assert.equal(resolved, "/tmp/custom/subagent-tasks.json");
+  } finally {
+    restoreEnv();
+  }
+});
+
+defineTest("resolveDefaultTaskPersistencePath uses XDG_DATA_HOME by default", () => {
+  try {
+    setEnv("OHM_SUBAGENTS_TASK_PERSIST_PATH", undefined);
+    setEnv("XDG_DATA_HOME", "/tmp/xdg-data");
+
+    const resolved = resolveDefaultTaskPersistencePath();
+    assert.equal(resolved, "/tmp/xdg-data/pi/agent/ohm.subagents.tasks.json");
+  } finally {
+    restoreEnv();
+  }
+});
+
+defineTest(
+  "resolveDefaultTaskPersistencePath falls back to ~/.local/share when XDG_DATA_HOME is unset",
+  () => {
+    try {
+      setEnv("OHM_SUBAGENTS_TASK_PERSIST_PATH", undefined);
+      setEnv("XDG_DATA_HOME", undefined);
+
+      const resolved = resolveDefaultTaskPersistencePath();
+      assert.equal(
+        resolved,
+        join(homedir(), ".local", "share", "pi", "agent", "ohm.subagents.tasks.json"),
+      );
+    } finally {
+      restoreEnv();
+    }
+  },
+);

package/src/tools/task/defaults.ts

@@ -47,20 +47,33 @@ function resolveTaskPersistenceDebounceMs(): number {
   return 90;
 }
 
+function parseNonEmptyEnvString(name: string): string | undefined {
+  const raw = process.env[name];
+  if (!raw) return undefined;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return undefined;
+  return trimmed;
+}
+
 export function resolveOnUpdateThrottleMs(): number {
   const fromEnv = parsePositiveIntegerEnv("OHM_SUBAGENTS_ONUPDATE_THROTTLE_MS");
   if (fromEnv !== undefined) return fromEnv;
   return 120;
 }
 
-function resolveDefaultTaskPersistencePath(): string {
-  const baseDir =
-    process.env.PI_CONFIG_DIR ??
-    process.env.PI_CODING_AGENT_DIR ??
-    process.env.PI_AGENT_DIR ??
-    join(homedir(), ".pi", "agent");
+function resolveTaskPersistenceDataDir(): string {
+  const xdgDataHome = parseNonEmptyEnvString("XDG_DATA_HOME");
+  if (xdgDataHome) {
+    return join(xdgDataHome, "pi", "agent");
+  }
+
+  return join(homedir(), ".local", "share", "pi", "agent");
+}
 
-  return join(baseDir, "ohm.subagents.tasks.json");
+export function resolveDefaultTaskPersistencePath(): string {
+  const explicitPath = parseNonEmptyEnvString("OHM_SUBAGENTS_TASK_PERSIST_PATH");
+  if (explicitPath) return explicitPath;
+  return join(resolveTaskPersistenceDataDir(), "ohm.subagents.tasks.json");
 }
 
 const DEFAULT_TASK_STORE = createInMemoryTaskRuntimeStore({

package/src/tools/task/execution/projection.ts

@@ -127,6 +127,8 @@ export function snapshotToTaskResultDetails(
     output_truncated: resolvedOutput.output_truncated,
     output_total_chars: resolvedOutput.output_total_chars,
     output_returned_chars: resolvedOutput.output_returned_chars,
+    updated_at_epoch_ms: snapshot.updatedAtEpochMs,
+    ended_at_epoch_ms: snapshot.endedAtEpochMs,
     backend: snapshot.backend,
     provider: snapshot.provider,
     model: snapshot.model,

package/src/tools/task/operations.lifecycle.test.ts

@@ -1337,11 +1337,13 @@ defineTest("runTaskToolMvp surfaces multiline output text in tool content", asyn
   }
 
   const plainText = stripAnsi(textBlock.text);
-  assert.match(plainText, /✓ Finder · Multiline/);
-  assert.match(plainText, /├── Return multiple lines/);
+  assert.match(plainText, /^task_id:\s+task_/m);
+  assert.match(plainText, /^timestamp:\s+\d{4}-\d{2}-\d{2}T/m);
+  assert.match(plainText, /^result:$/m);
   assert.match(plainText, /alpha/);
   assert.match(plainText, /beta/);
   assert.match(plainText, /gamma/);
+  assert.doesNotMatch(plainText, /├──|╰──|✓|✕/);
 });
 
 defineTest("runTaskToolMvp always returns full output for long payloads", async () => {
@@ -1391,8 +1393,12 @@ defineTest("runTaskToolMvp always returns full output for long payloads", async
       assert.fail("Expected text content block");
     }
 
-    assert.doesNotMatch(textBlock.text, /truncated/);
-    assert.match(textBlock.text, /abcdefghijklmnopqrstuvwxyz0123456789/);
+    const plainText = stripAnsi(textBlock.text);
+    assert.match(plainText, /^task_id:\s+task_/m);
+    assert.match(plainText, /^timestamp:\s+\d{4}-\d{2}-\d{2}T/m);
+    assert.match(plainText, /^result:$/m);
+    assert.doesNotMatch(plainText, /truncated/);
+    assert.match(plainText, /abcdefghijklmnopqrstuvwxyz0123456789/);
   } finally {
     if (previous === undefined) {
       delete process.env.OHM_SUBAGENTS_OUTPUT_MAX_CHARS;
@@ -2535,7 +2541,12 @@ defineTest("runTaskToolMvp uses assistant_text from events for terminal result r
     assert.fail("Expected text block");
   }
 
-  assert.match(textBlock.text, /structured final answer/);
+  const plainText = stripAnsi(textBlock.text);
+  assert.match(plainText, /^task_id:\s+task_/m);
+  assert.match(plainText, /^timestamp:\s+\d{4}-\d{2}-\d{2}T/m);
+  assert.match(plainText, /^result:$/m);
+  assert.match(plainText, /structured final answer/);
+  assert.doesNotMatch(plainText, /tool_call:|├──|╰──|✓/);
 });
 
 defineTest("runTaskToolMvp status aggregates runtime observability from task items", async () => {

package/src/tools/task/render.ts

@@ -85,6 +85,80 @@ function withItemObservabilityDefaults(item: TaskToolItemDetails): TaskToolItemD
   };
 }
 
+function toIsoTimestamp(epochMs: number | undefined): string | undefined {
+  if (typeof epochMs !== "number" || !Number.isFinite(epochMs)) return undefined;
+  const date = new Date(epochMs);
+  if (Number.isNaN(date.getTime())) return undefined;
+  return date.toISOString();
+}
+
+function extractNarrativeResult(output: string | undefined): string | undefined {
+  if (!output) return undefined;
+  const sections = parseTaskTranscriptSections(output);
+  if (sections.narrativeLines.length === 0) return undefined;
+  return sections.narrativeLines.join("\n");
+}
+
+function resolveModelResultText(details: TaskToolResultDetails): string {
+  const assistantText = details.assistant_text?.trim();
+  if (assistantText && assistantText.length > 0) return assistantText;
+
+  const outputNarrative =
+    details.output_available && details.output ? extractNarrativeResult(details.output) : undefined;
+  if (outputNarrative && outputNarrative.length > 0) return outputNarrative;
+
+  if (details.items && details.items.length === 1) {
+    const [item] = details.items;
+    if (item && item.found) {
+      const itemAssistantText = item.assistant_text?.trim();
+      if (itemAssistantText && itemAssistantText.length > 0) return itemAssistantText;
+
+      const itemNarrative =
+        item.output_available && item.output ? extractNarrativeResult(item.output) : undefined;
+      if (itemNarrative && itemNarrative.length > 0) return itemNarrative;
+
+      if (item.error_message && item.error_message.length > 0) return item.error_message;
+      return item.summary;
+    }
+  }
+
+  if (details.error_message && details.error_message.length > 0) return details.error_message;
+  return details.summary;
+}
+
+function resolveModelTaskId(details: TaskToolResultDetails): string {
+  if (details.task_id && details.task_id.length > 0) return details.task_id;
+  if (details.items && details.items.length === 1) {
+    const [item] = details.items;
+    if (item && item.id.length > 0) return item.id;
+  }
+  return "unavailable";
+}
+
+function resolveModelTimestamp(details: TaskToolResultDetails): string {
+  const directTimestamp =
+    toIsoTimestamp(details.ended_at_epoch_ms) ?? toIsoTimestamp(details.updated_at_epoch_ms);
+  if (directTimestamp) return directTimestamp;
+
+  if (details.items && details.items.length === 1) {
+    const [item] = details.items;
+    if (item) {
+      const itemTimestamp =
+        toIsoTimestamp(item.ended_at_epoch_ms) ?? toIsoTimestamp(item.updated_at_epoch_ms);
+      if (itemTimestamp) return itemTimestamp;
+    }
+  }
+
+  return "unavailable";
+}
+
+function toModelFacingContent(details: TaskToolResultDetails): string {
+  const taskId = resolveModelTaskId(details);
+  const timestamp = resolveModelTimestamp(details);
+  const result = resolveModelResultText(details);
+  return [`task_id: ${taskId}`, `timestamp: ${timestamp}`, "result:", result].join("\n");
+}
+
 export function isOhmDebugEnabled(): boolean {
   const raw = process.env.OHM_DEBUG?.trim().toLowerCase();
   if (!raw) return false;
@@ -658,7 +732,7 @@ export function toAgentToolResult(
   );
 
   return {
-    content: [{ type: "text", text: detailsToText(normalizedDetails, true) }],
+    content: [{ type: "text", text: toModelFacingContent(normalizedDetails) }],
     details: normalizedDetails,
   };
 }