@trevonistrevon/pi-loop 0.6.2 → 0.6.4

package/src/tools/native-task-tools.ts

@@ -9,7 +9,8 @@ import {
 } from "../runtime/task-mutations.js";
 import { TaskStore } from "../task-store.js";
 import type { TaskStatus } from "../task-types.js";
-import { textResult } from "./tool-result.js";
+import { renderToolCall, renderToolResult, toolArg } from "../ui/tool-renderer.js";
+import { displayRows, textResult } from "./tool-result.js";
 
 export type { TaskBacklogResult };
 
@@ -33,6 +34,8 @@ export function registerNativeTaskTools(options: NativeTaskToolsOptions): void {
   pi.registerTool({
     name: "TaskCreate",
     label: "TaskCreate",
+    renderCall: renderToolCall("Task", (args) => `create · ${String(toolArg(args, "subject") ?? "task").slice(0, 56)}`),
+    renderResult: renderToolResult,
     description: `Create a task for tracking work across turns. Use when you need to track progress on complex multi-step tasks or turn a broad user goal into a concrete backlog.
 
 Fields:
@@ -59,18 +62,33 @@ Fields:
         subject: params.subject,
         description: params.description,
       });
-      return textResult(`Task #${entry.id} created: ${entry.subject}${backlogSuffix(backlog)}`);
+      return textResult(`Task #${entry.id} created: ${entry.subject}${backlogSuffix(backlog)}`, {
+        kind: "task",
+        action: "create",
+        tone: "success",
+        summary: `Task #${entry.id} pending · ${entry.subject.slice(0, 56)}`,
+        expanded: [
+          `Description: ${entry.description}`,
+          backlog.created && backlog.entry ? `Backlog worker: loop #${backlog.entry.id} created` : "Backlog worker: unchanged",
+        ],
+      });
     },
   });
 
   pi.registerTool({
     name: "TaskList",
     label: "TaskList",
+    renderCall: renderToolCall("Task", () => "status"),
+    renderResult: renderToolResult,
     description: "List all tasks with status. Use to check progress and find available work.",
     parameters: Type.Object({}),
     execute() {
       const tasks = taskStore.list();
-      if (tasks.length === 0) return Promise.resolve(textResult("No tasks."));
+      if (tasks.length === 0) {
+        return Promise.resolve(textResult("No tasks.", {
+          kind: "task", action: "list", tone: "info", summary: "No tasks", expanded: ["Use TaskCreate for work that spans turns."],
+        }));
+      }
 
       const lines: string[] = [];
       const statuses: Record<"pending" | "in_progress" | "completed", number> = {
@@ -84,13 +102,21 @@ Fields:
         lines.push(`${icon} #${t.id} [${t.status}] ${t.subject.slice(0, 80)}`);
       }
       lines.unshift(`${tasks.length} tasks (${statuses.pending} pending, ${statuses.in_progress} in progress, ${statuses.completed} done)`);
-      return Promise.resolve(textResult(lines.join("\n")));
+      return Promise.resolve(textResult(lines.join("\n"), {
+        kind: "task",
+        action: "list",
+        tone: "info",
+        summary: `${tasks.length} task${tasks.length === 1 ? "" : "s"} · ${statuses.pending} pending · ${statuses.in_progress} active`,
+        expanded: displayRows(lines.slice(1)),
+      }));
     },
   });
 
   pi.registerTool({
     name: "TaskUpdate",
     label: "TaskUpdate",
+    renderCall: renderToolCall("Task", (args) => `update · #${String(toolArg(args, "id") ?? "?")}`),
+    renderResult: renderToolResult,
     description: `Update task status or details. Set status to "in_progress" before starting work, "completed" when done.
 
 Statuses: pending → in_progress → completed
@@ -114,23 +140,45 @@ Parameters: id (required), status, subject, description`,
         subject,
         description,
       });
-      if (!result) return textResult(`Task #${id} not found`);
+      if (!result) {
+        return textResult(`Task #${id} not found`, {
+          kind: "task", action: "update", tone: "error", summary: `Task #${id} not found`, expanded: ["Use TaskList to find valid task IDs."],
+        });
+      }
       const statusMsg = status ? ` → ${status}` : "";
-      return textResult(`Task #${id} updated${statusMsg}${backlogSuffix(result.backlog)}`);
+      return textResult(`Task #${id} updated${statusMsg}${backlogSuffix(result.backlog)}`, {
+        kind: "task",
+        action: "update",
+        tone: "success",
+        summary: `Task #${id}${status ? ` → ${status}` : " updated"}`,
+        expanded: [
+          `Subject: ${result.entry.subject}`,
+          `Status: ${result.entry.status}`,
+          result.backlog.created && result.backlog.entry ? `Backlog worker: loop #${result.backlog.entry.id} created` : "Backlog worker: unchanged",
+        ],
+      });
     },
   });
 
   pi.registerTool({
     name: "TaskDelete",
     label: "TaskDelete",
+    renderCall: renderToolCall("Task", (args) => `delete · #${String(toolArg(args, "id") ?? "?")}`),
+    renderResult: renderToolResult,
     description: "Delete a task by ID. Use for cleaning up completed or irrelevant tasks.",
     parameters: Type.Object({
       id: Type.String({ description: "Task ID to delete" }),
     }),
     async execute(_toolCallId, params) {
       const result = await deleteTask(mutationCtx, params.id);
-      if (!result) return textResult(`Task #${params.id} not found`);
-      return textResult(`Task #${params.id} deleted`);
+      if (!result) {
+        return textResult(`Task #${params.id} not found`, {
+          kind: "task", action: "delete", tone: "error", summary: `Task #${params.id} not found`, expanded: ["Use TaskList to find valid task IDs."],
+        });
+      }
+      return textResult(`Task #${params.id} deleted`, {
+        kind: "task", action: "delete", tone: "success", summary: `Task #${params.id} deleted`, expanded: [],
+      });
     },
   });
 }

package/src/tools/tool-result.ts

@@ -1,4 +1,20 @@
 /** Plain-text tool result in the shape pi's registerTool expects. */
-export function textResult(msg: string) {
-  return { content: [{ type: "text" as const, text: msg }], details: undefined };
+export type ToolDisplayKind = "loop" | "workflow" | "task" | "monitor";
+export type ToolDisplayTone = "success" | "warning" | "error" | "info";
+
+export interface ToolDisplayDetails {
+  kind: ToolDisplayKind;
+  action: string;
+  tone: ToolDisplayTone;
+  summary: string;
+  expanded?: string[];
+}
+
+export function displayRows(rows: string[], limit = 8): string[] {
+  if (rows.length <= limit) return rows;
+  return [...rows.slice(0, limit), `… ${rows.length - limit} more`];
+}
+
+export function textResult(msg: string, details?: ToolDisplayDetails) {
+  return { content: [{ type: "text" as const, text: msg }], details };
 }

package/src/types.ts

@@ -47,6 +47,46 @@ export interface DynamicLoopState {
   lastUpdatedAt?: number;
 }
 
+export type WorkflowTerminalStatus = "completed" | "paused";
+
+export interface WorkflowTaskDefinition {
+  subject: string;
+  description: string;
+}
+
+export interface WorkflowStateDefinition {
+  prompt: string;
+  task?: WorkflowTaskDefinition;
+  on?: Record<string, string>;
+  terminal?: WorkflowTerminalStatus;
+  maxAttempts?: number;
+}
+
+export interface WorkflowDefinition {
+  version: 1;
+  initialState: string;
+  states: Record<string, WorkflowStateDefinition>;
+}
+
+export interface WorkflowTransitionRecord {
+  from: string;
+  to: string;
+  outcome: string;
+  evidence?: string;
+  at: number;
+  sequence: number;
+}
+
+export interface WorkflowRunState {
+  definition: WorkflowDefinition;
+  currentState: string;
+  transitionSeq: number;
+  stateEnteredAt: number;
+  attemptsByState: Record<string, number>;
+  activeTaskId?: string;
+  lastTransition?: WorkflowTransitionRecord;
+}
+
 export interface LoopEntry {
   id: string;
   prompt: string;
@@ -62,6 +102,7 @@ export interface LoopEntry {
   maxFires?: number;
   fireCount?: number;
   dynamic?: DynamicLoopState;
+  workflow?: WorkflowRunState;
 }
 
 export interface LoopStoreData {

package/src/ui/tool-renderer.ts

@@ -0,0 +1,45 @@
+import type { AgentToolResult, Theme, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import type { ToolDisplayDetails } from "../tools/tool-result.js";
+
+type ToolCallArgs = object;
+
+export function renderToolCall(label: string, summarize: (args: ToolCallArgs) => string) {
+  return (args: ToolCallArgs, theme: Theme) => {
+    const summary = summarize(args);
+    const text = theme.fg("toolTitle", theme.bold(`${label} `)) + theme.fg("muted", summary);
+    return new Text(text, 0, 0);
+  };
+}
+
+export function toolArg(args: ToolCallArgs, name: string): unknown {
+  return (args as Record<string, unknown>)[name];
+}
+
+export function renderToolResult(
+  result: AgentToolResult<unknown>,
+  { expanded, isPartial }: ToolRenderResultOptions,
+  theme: Theme,
+) {
+  if (isPartial) return new Text(theme.fg("warning", "Working…"), 0, 0);
+
+  const details = result.details as ToolDisplayDetails | undefined;
+  if (!details) {
+    const content = result.content[0];
+    return new Text(content?.type === "text" ? content.text : "No result", 0, 0);
+  }
+
+  const color = details.tone === "success"
+    ? "success"
+    : details.tone === "warning"
+      ? "warning"
+      : details.tone === "error"
+        ? "error"
+        : "muted";
+  const icon = details.tone === "success" ? "✓" : details.tone === "error" ? "✕" : details.tone === "warning" ? "!" : "•";
+  let text = theme.fg(color, `${icon} ${details.summary}`);
+  if (expanded && details.expanded?.length) {
+    for (const line of details.expanded) text += `\n${theme.fg("dim", line)}`;
+  }
+  return new Text(text, 0, 0);
+}

package/src/ui/widget.ts

@@ -36,7 +36,7 @@ export class LoopWidget {
 
   private computeStatus(): string | undefined {
     const loops = this.store.list().filter(isStatusVisibleLoop);
-    const monitors = this.monitorManager.list();
+    const monitors = this.monitorManager.list().filter((monitor) => monitor.status === "running");
     const taskSummary = this.taskSummaryProvider?.() ?? { count: 0 };
 
     if (loops.length === 0 && monitors.length === 0 && taskSummary.count === 0) {
@@ -44,9 +44,9 @@ export class LoopWidget {
     }
 
     const parts: string[] = [];
-    if (loops.length > 0) parts.push(formatCount(loops.length, "loop"));
-    if (monitors.length > 0) parts.push(formatCount(monitors.length, "monitor"));
-    if (taskSummary.count > 0) parts.push(formatCount(taskSummary.count, "task"));
+    if (loops.length > 0) parts.push(`↻ ${formatCount(loops.length, "loop")}`);
+    if (monitors.length > 0) parts.push(`▶ ${formatCount(monitors.length, "monitor")}`);
+    if (taskSummary.count > 0) parts.push(`□ ${formatCount(taskSummary.count, "task")}`);
 
     let line = parts.join(" · ");
     if (taskSummary.focusText) line += ` | ${taskSummary.focusText}`;

package/src/workflow-reducer.ts

@@ -0,0 +1,107 @@
+import type {
+  WorkflowDefinition,
+  WorkflowRunState,
+  WorkflowTerminalStatus,
+  WorkflowTransitionRecord,
+} from "./types.js";
+
+export type {
+  WorkflowDefinition,
+  WorkflowRunState,
+  WorkflowStateDefinition,
+  WorkflowTerminalStatus,
+  WorkflowTransitionRecord,
+} from "./types.js";
+
+export interface WorkflowTransitionInput {
+  outcome: string;
+  evidence?: string;
+  activeTaskId?: string;
+}
+
+export type WorkflowTransitionResult =
+  | { applied: true; run: WorkflowRunState; terminal?: WorkflowTerminalStatus }
+  | { applied: false; error: string };
+
+export function validateWorkflowDefinition(definition: WorkflowDefinition): string | undefined {
+  if (!definition || definition.version !== 1) return "Workflow version must be 1";
+  if (!definition.states || typeof definition.states !== "object") return "Workflow states must be an object";
+  if (!definition.initialState || !definition.states[definition.initialState]) {
+    return `Initial state "${definition.initialState}" is not defined`;
+  }
+
+  for (const [stateId, state] of Object.entries(definition.states)) {
+    if (!stateId) return "Workflow state IDs must be non-empty";
+    if (!state || typeof state !== "object") return `State "${stateId}" must be an object`;
+    if (typeof state.prompt !== "string") return `State "${stateId}" requires a prompt`;
+    if (!state.prompt.trim()) return `State "${stateId}" requires a prompt`;
+    if (state.on !== undefined && (typeof state.on !== "object" || Array.isArray(state.on))) {
+      return `State "${stateId}" transitions must be an object`;
+    }
+    if (state.terminal && state.on && Object.keys(state.on).length > 0) {
+      return `Terminal state "${stateId}" cannot declare transitions`;
+    }
+    if (state.maxAttempts !== undefined && (!Number.isInteger(state.maxAttempts) || state.maxAttempts < 1)) {
+      return `State "${stateId}" maxAttempts must be a positive integer`;
+    }
+    for (const [outcome, target] of Object.entries(state.on ?? {})) {
+      if (!outcome) return `State "${stateId}" has an empty outcome name`;
+      if (typeof target !== "string") return `Transition "${stateId}.${outcome}" target must be a state ID`;
+      if (!definition.states[target]) return `Transition "${stateId}.${outcome}" targets unknown state "${target}"`;
+    }
+  }
+
+  return undefined;
+}
+
+export function createWorkflowRun(definition: WorkflowDefinition, at: number): WorkflowRunState {
+  return {
+    definition,
+    currentState: definition.initialState,
+    transitionSeq: 0,
+    stateEnteredAt: at,
+    attemptsByState: { [definition.initialState]: 1 },
+  };
+}
+
+export function transitionWorkflowRun(
+  run: WorkflowRunState,
+  input: WorkflowTransitionInput,
+  at: number,
+): WorkflowTransitionResult {
+  const current = run.definition.states[run.currentState];
+  if (!current) return { applied: false, error: `Current state "${run.currentState}" is not defined` };
+  if (current.terminal) return { applied: false, error: `Workflow is already ${current.terminal}` };
+
+  const target = current.on?.[input.outcome];
+  if (!target) return { applied: false, error: `Outcome "${input.outcome}" is not allowed from state "${run.currentState}"` };
+
+  const targetState = run.definition.states[target];
+  if (!targetState) return { applied: false, error: `Transition target "${target}" is not defined` };
+
+  const nextAttempt = (run.attemptsByState[target] ?? 0) + 1;
+  if (targetState.maxAttempts !== undefined && nextAttempt > targetState.maxAttempts) {
+    return { applied: false, error: `State "${target}" has exhausted its ${targetState.maxAttempts} attempt limit` };
+  }
+
+  const sequence = run.transitionSeq + 1;
+  const lastTransition: WorkflowTransitionRecord = {
+    from: run.currentState,
+    to: target,
+    outcome: input.outcome,
+    evidence: input.evidence,
+    at,
+    sequence,
+  };
+  const nextRun: WorkflowRunState = {
+    ...run,
+    currentState: target,
+    transitionSeq: sequence,
+    stateEnteredAt: at,
+    attemptsByState: { ...run.attemptsByState, [target]: nextAttempt },
+    activeTaskId: input.activeTaskId,
+    lastTransition,
+  };
+
+  return { applied: true, run: nextRun, terminal: targetState.terminal };
+}