pi-better-goal 0.10.1 → 0.10.2

package/README.md

@@ -21,6 +21,12 @@ Use `pi-better-goal` when a Pi session should keep an explicit objective visible
 - A progress-aware follow-up loop with ten identical no-progress retries and linear backoff (60s through 600s by default), followed by a sticky hold recoverable with `/goal resume` or `alt+g`. Conversation, changed callback results, and background drains do not reopen an exhausted hold. Delays saturate at Node's timer limit, and observed background drains reset non-held progress before callback turns can cancel the wake. Pi's network retry policy remains independent.
 - An observable-progress stall state for active goals.
 
+## Optional Harness-Owned Outcome & Todo
+
+When `pi-better-harness` is installed, its optional **Outcome & Todo** runtime owns the session's structured outcome and checklist. Goal keeps its own objective, clocks, pause and permission holds, workflow gates, background wake behavior, and continuation policy; it also sends lifecycle requests to the Harness runtime so a bound outcome starts, pauses, resumes, and completes with the Goal. When the runtime is present, Goal stops adding its own active-objective text to avoid duplicating the Harness-owned outcome, whether Outcome & Todo is enabled or off.
+
+`/goal` does not install, enable, or configure Outcome & Todo. Install Harness and enable **Outcome & Todo** in `/harness-settings` if you want that shared outcome and checklist. Without Harness, this package keeps its standalone prompts and behavior unchanged. The stored Goal objective remains the raw original trigger (for example, a bound command invocation) so `/goal resume` can re-enter the work; it is not the authoritative business outcome when Harness owns one.
+
 ## Settings Storage
 
 Goal preferences are saved only in Pi's global `~/.pi/agent/settings.json` under

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-goal",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "Pi extension for goal tracking with background-aware continuation.",
   "license": "MIT",
   "type": "module",

package/src/index.ts

@@ -42,6 +42,7 @@ import { collectSubagentActivity } from "./subagents.js";
 import { currentWorkflowOwner, skillCommandName, workflowEntry, workflowOwnerFromSkill, WORKFLOW_ENTRY_TYPE } from "./workflow.js";
 import { completionGate, pauseGate, schedulerWaitUntil } from "./workflow-gates.js";
 import { workflowRehydrateMessage, WORKFLOW_REHYDRATE_MESSAGE_TYPE } from "./rehydrate.js";
+import { requestTaskContext } from "./task-context.js";
 import {
   EVENT_ACTIVITY,
   EVENT_READY,
@@ -103,11 +104,11 @@ export function pausedGoalStatus(goal: GoalSnapshot, conversationalResume = true
   return agentResumable(goal, conversationalResume) ? 'goal paused · say "go" or /goal resume' : "goal paused · /goal resume";
 }
 
-function pausedGoalPrompt(goal: GoalSnapshot, conversationalResume: boolean): string {
+function pausedGoalPrompt(goal: GoalSnapshot, conversationalResume: boolean, includeObjective = true): string {
   return [
     goal.pauseReason === "handback"
-      ? `Pi Better Goal is paused because its workflow handed back unfinished work for the user's answer. Goal: ${goal.objective}`
-      : `Pi Better Goal is paused because the user pressed escape. Goal: ${goal.objective}`,
+      ? `Pi Better Goal is paused because its workflow handed back unfinished work for the user's answer.${includeObjective ? ` Goal: ${goal.objective}` : ""}`
+      : `Pi Better Goal is paused because the user pressed escape.${includeObjective ? ` Goal: ${goal.objective}` : ""}`,
     "Treat the user's messages as ordinary conversation: answer them, but do not continue the goal's work until it is resumed.",
     conversationalResume ? GOAL_RESUME_RULE : "Only the user can resume this goal, with /goal resume or alt+g. A conversational go-ahead does not resume it.",
   ].join("\n");
@@ -407,6 +408,17 @@ export default function (pi: ExtensionAPI): void {
     const previous = getGoal(ctx);
     const wasVisible = previous !== null && isGoalClockVisible(previous);
     pi.appendEntry(EXTENSION_NAME, goalSetEntry(goal, source));
+    // Bridge lifecycle after the raw Goal entry is durable. Harness may own the
+    // structured outcome, but Goal still owns its trigger, clocks, pauses, and wakes.
+    if (!previous || previous.goalId !== goal.goalId) {
+      requestTaskContext(pi, "start", goal);
+    } else if (goal.status === "complete") {
+      requestTaskContext(pi, "complete", goal);
+    } else if (goal.status === "paused" || goal.status === "budgetLimited") {
+      requestTaskContext(pi, "pause", goal);
+    } else if (goal.status === "active" && previous.status !== "active") {
+      requestTaskContext(pi, "resume", goal);
+    }
     continuationQueuedFor = null;
     backgroundDrainTracker = null;
     clearIdleContinuation();
@@ -422,6 +434,8 @@ export default function (pi: ExtensionAPI): void {
     lastAgentEvidence = null;
     const current = getGoal(ctx);
     const wasVisible = current !== null && isGoalClockVisible(current);
+    // Clearing pauses a Harness-bound outcome; it never deletes or completes it.
+    if (current) requestTaskContext(pi, "pause", current);
     pi.appendEntry(EXTENSION_NAME, goalClearEntry(current?.goalId ?? null, source));
     if (getWorkflow(ctx)) recordWorkflow(null);
     continuationQueuedFor = null;
@@ -868,6 +882,11 @@ export default function (pi: ExtensionAPI): void {
             }
             const nextRenderDelay = goalClockRefreshDelayMs(goal);
             if (nextRenderDelay !== null) scheduler.schedule(nextRenderDelay);
+            // Schedule before handing visual ownership to Harness so its header
+            // keeps ticking. An absent display response preserves standalone Goal.
+            if (requestTaskContext(pi, "inspect", goal, width).display === true) {
+              return [];
+            }
             const fg = typeof theme?.fg === "function"
               ? (color: string, value: string) => theme.fg(color as never, value)
               : undefined;
@@ -1318,6 +1337,9 @@ export default function (pi: ExtensionAPI): void {
     currentCtx = ctx;
     const goal = currentGoalSnapshot(ctx);
     const owner = getWorkflow(ctx);
+    // A defined `enabled` means a Harness runtime is present, even when
+    // Outcome & Todo is off. Then Harness owns the structured outcome text.
+    const harnessPresent = requestTaskContext(pi, "inspect", goal).enabled !== undefined;
     const snapshot = await publishSnapshot(ctx);
     if (!snapshot) return;
     const permissions = goal ? currentPermissionHold(ctx, goal.goalId) : null;
@@ -1330,7 +1352,7 @@ export default function (pi: ExtensionAPI): void {
       return { systemPrompt: `${event.systemPrompt}\n\n${permissionPrompt}` };
     }
     const pausedInstruction = permissionPrompt || (goal?.status === "paused" && (goal.pauseReason === "interrupt" || goal.pauseReason === "handback")
-      ? pausedGoalPrompt(goal, preferences.conversationalResume) : "");
+      ? pausedGoalPrompt(goal, preferences.conversationalResume, !harnessPresent) : "");
     if (!isPokeable(goal) && !owner) {
       return pausedInstruction ? { systemPrompt: `${event.systemPrompt}\n\n${pausedInstruction}` } : undefined;
     }
@@ -1363,7 +1385,11 @@ export default function (pi: ExtensionAPI): void {
               : "While the goal is paused, this overrides the workflow instructions below: do not advance the workflow until the goal is resumed.\n\n")
             : "") +
           `Active workflow: ${owner.name} (${owner.path}). Its task plan owns planning and the parent is a coordinator, not a product-code implementer. Follow the workflow instructions below, including on resumed turns:\n\n${instructions}` +
-          (isPokeable(goal) ? `\n\nActive objective: ${goal.objective}. Complete it only after the workflow completion audit.` : "") +
+          (isPokeable(goal)
+            ? harnessPresent
+              ? "\n\nComplete the goal only after the workflow completion audit."
+              : `\n\nActive objective: ${goal.objective}. Complete it only after the workflow completion audit.`
+            : "") +
           (questionInstruction ? `\n\n${questionInstruction.trim()}` : "") +
           (heldInstruction ? `\n\n${heldInstruction}` : ""),
       };
@@ -1373,6 +1399,15 @@ export default function (pi: ExtensionAPI): void {
     const backgroundInstruction = snapshot.backgroundRunning
       ? ` The goal still has delegated background work running (${summarizeActiveBackground(snapshot)}). Foreground idleness alone is not goal completion; keep any structured plan current and do not mark verification, the plan, or the goal complete until every relevant delegated task reaches a terminal state and its result or failure has been inspected and integrated.`
       : "";
+    if (harnessPresent) {
+      // Harness owns the outcome text. Retain only the Goal-specific guidance
+      // that the Outcome & Todo prompt cannot replace.
+      const retained = [heldInstruction, backgroundInstruction.trim(), questionInstruction.trim(), permissionPrompt]
+        .filter((part) => part.length > 0);
+      return retained.length > 0
+        ? { systemPrompt: `${event.systemPrompt}\n\n${retained.join("\n\n")}` }
+        : undefined;
+    }
     return {
       systemPrompt:
         `${event.systemPrompt}\n\n` +

package/src/task-context.ts

@@ -0,0 +1,50 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { GoalSnapshot } from "./types.js";
+
+/** Synchronous request bus shared with an installed `pi-better-harness` runtime. */
+export const TASK_CONTEXT_EVENT = "pi-better-harness:task-context";
+
+export type TaskContextAction = "inspect" | "start" | "pause" | "resume" | "complete";
+
+/**
+ * Mutable request. A present Harness runtime sets `enabled` to a boolean even
+ * when Outcome & Todo is off. Without Harness the field stays undefined, which
+ * lets Goal retain its standalone behavior.
+ */
+export interface TaskContextRequest {
+  action: TaskContextAction;
+  goalId?: string;
+  /** Current widget width on a visual ownership inspection. */
+  width?: number;
+  /** The raw original goal trigger; only start requests carry it. */
+  objective?: string;
+  /** Hooks authority: a present Harness runtime sets this even when Outcome & Todo is off. */
+  enabled?: boolean;
+  /**
+   * Visual ownership. A Harness runtime sets this on `inspect` responses when
+   * its combined Todo header is rendering the requested `goalId`. It is
+   * independent of `enabled` and stays undefined without Harness, so Goal keeps
+   * its standalone clock widget whenever that header does not own the goal.
+   */
+  display?: boolean;
+}
+
+/**
+ * Emit one task-context request and return it so the caller can inspect the
+ * Harness-owned `enabled` field after synchronous listeners run.
+ */
+export function requestTaskContext(
+  pi: Pick<ExtensionAPI, "events">,
+  action: TaskContextAction,
+  goal?: GoalSnapshot | null,
+  width?: number,
+): TaskContextRequest {
+  const request: TaskContextRequest = { action };
+  if (width !== undefined) request.width = width;
+  if (goal) {
+    request.goalId = goal.goalId;
+    if (action === "start") request.objective = goal.objective;
+  }
+  pi.events.emit(TASK_CONTEXT_EVENT, request);
+  return request;
+}