@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/long-horizon/src/runtime.ts

@@ -4,14 +4,13 @@
  *   tool_call    → TurnActivity accumulation (bash commands, edit/write
  *                  files, call count)
  *   agent_end    → extract recent tail + token totals, run continuation
- *                  settlement, deliver the next message
- *   continuation.send → pi.sendUserMessage (a follow-up user turn: the gate
- *                  re-resolves, the owner wins, the loop continues)
+ *                  settlement, fill the arbiter's nudge stash (delivered by
+ *                  the single agent_before_settle nudge, long-horizon/index.ts)
  *   verifier     → modelRegistry.complete on the session model (or the
  *                  configured verifier model)
  *
- * The loop closes here: agent_end → settle → sendUserMessage → next turn →
- * agent_end … bounded by maxTurns / stall cap / token budget.
+ * The loop closes here: agent_end → settle → stash → before_settle nudge →
+ * next turn → agent_end … bounded by maxTurns / stall cap / token budget.
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -24,6 +23,9 @@ import type { RalphLoop } from "./engine/ralph.js";
 import type { LongHorizonSettings } from "./settings.js";
 import { loadSettings } from "./settings.js";
 import { RunawayGuard } from "./engine/runaway.js";
+import { appendProgress, registerProgressRenderer, sendHarnessUserMessage, UNIPI_EVENTS } from "@pi-unipi/core";
+import { goalEstimatePrompt, goalProgressData, parseEstimate, type GoalEvidence } from "./progress.js";
+import { TERMINAL_GOAL_STATUSES } from "./engine/goal-state.js";
 
 /** Extract command/file signals from a tool call for the activity record. */
 export function classifyToolCall(
@@ -88,7 +90,9 @@ export function extractTail(
     .filter((entry) => entry.text.length > 0);
 }
 
-/** Best-effort cumulative token count from assistant usage fields. */
+/** Best-effort cumulative token count from assistant usage fields. Accepts
+ *  both shapes pi providers emit: {input, output, cacheRead, cacheWrite,
+ *  totalTokens} and {inputTokens, outputTokens}. */
 export function sumUsageTokens(messages: readonly unknown[]): number | undefined {
   let total = 0;
   let seen = false;
@@ -102,8 +106,16 @@ export function sumUsageTokens(messages: readonly unknown[]): number | undefined
       seen = true;
       continue;
     }
-    const input = typeof record.inputTokens === "number" ? record.inputTokens : 0;
-    const output = typeof record.outputTokens === "number" ? record.outputTokens : 0;
+    const input = typeof record.input === "number"
+      ? record.input
+      : typeof record.inputTokens === "number"
+        ? record.inputTokens
+        : 0;
+    const output = typeof record.output === "number"
+      ? record.output
+      : typeof record.outputTokens === "number"
+        ? record.outputTokens
+        : 0;
     if (input + output > 0) {
       total += input + output;
       seen = true;
@@ -112,6 +124,58 @@ export function sumUsageTokens(messages: readonly unknown[]): number | undefined
   return seen ? total : undefined;
 }
 
+/**
+ * Char-based token estimate (ceil(chars/4)) over a turn's assistant text,
+ * thinking, tool-call args, and toolResult text. Used when a provider reports
+ * no usable usage so the budget still bounds the loop.
+ */
+export function estimateTokens(messages: readonly unknown[]): number {
+  let chars = 0;
+  const countText = (value: unknown): void => {
+    if (typeof value === "string") chars += value.length;
+  };
+  for (const message of messages) {
+    if (typeof message !== "object" || message === null) continue;
+    const record = message as Record<string, unknown>;
+    const role = typeof record.role === "string" ? record.role : undefined;
+    const content = record.content;
+    if (role === "assistant") {
+      if (typeof content === "string") {
+        chars += content.length;
+      } else if (Array.isArray(content)) {
+        for (const part of content) {
+          if (typeof part !== "object" || part === null) continue;
+          const block = part as Record<string, unknown>;
+          if (block.type === "text") countText(block.text);
+          else if (block.type === "thinking") countText(block.thinking);
+          else if (block.type === "toolCall" || block.type === "tool_call" || block.type === "toolUse" || block.type === "tool_use") {
+            const args = block.arguments !== undefined ? block.arguments : block.input;
+            if (typeof args === "string") {
+              chars += args.length;
+            } else if (args !== undefined && args !== null) {
+              try {
+                chars += JSON.stringify(args).length;
+              } catch {
+                // Unserializable args just don't count.
+              }
+            }
+          }
+        }
+      }
+    } else if (role === "toolResult" || role === "tool_result") {
+      if (typeof content === "string") chars += content.length;
+      else if (Array.isArray(content)) {
+        for (const part of content) {
+          if (typeof part === "object" && part !== null && (part as Record<string, unknown>).type === "text") {
+            countText((part as Record<string, unknown>).text);
+          }
+        }
+      }
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+
 export interface RuntimeDeps {
   readonly machine: GoalMachine;
   readonly toolset: GoalToolset;
@@ -126,8 +190,14 @@ interface EvalContext {
   model: ExtensionContext["model"];
 }
 
-export function wireRuntime(pi: ExtensionAPI, deps: RuntimeDeps): void {
+export interface RuntimeHandle {
+  /** Estimate goal progress now and post it (user-only). */
+  estimateGoal(ctx?: ExtensionContext): Promise<"ok" | "none" | "failed">;
+}
+
+export function wireRuntime(pi: ExtensionAPI, deps: RuntimeDeps): RuntimeHandle {
   const settings = deps.loadSettings ?? loadSettings;
+  registerProgressRenderer(pi);
 
   // ── per-turn activity accumulator ───────────────────────────────────
   let toolCalls = 0;
@@ -151,12 +221,31 @@ export function wireRuntime(pi: ExtensionAPI, deps: RuntimeDeps): void {
   // ── runaway guard: feed steps, steer once per turn ─────────────────
   const runaway = new RunawayGuard({
     steer: (text) => {
-      void pi.sendUserMessage(text, { deliverAs: "steer" });
+      sendHarnessUserMessage(
+        pi,
+        text,
+        { source: "Progress guard", title: "No-progress guard", synopsis: "Repeated work detected", severity: "warning" },
+        { deliverAs: "steer" },
+      );
     },
   });
+  // pi's tool_execution_end carries no input — capture args per call at
+  // execution start and join them at the end, so "identical arguments" keys
+  // on real arguments instead of collapsing to one hash for the whole tool.
+  const argsByCallId = new Map<string, unknown>();
+  pi.on("tool_execution_start", (event) => {
+    try {
+      const startEvent = event as { toolCallId?: string; args?: unknown };
+      if (typeof startEvent.toolCallId === "string") {
+        argsByCallId.set(startEvent.toolCallId, startEvent.args);
+      }
+    } catch {
+      // Detector instrumentation must never abort a turn.
+    }
+  });
   pi.on("tool_execution_end", (event) => {
     try {
-    const toolEvent = event as { toolName?: string; result?: unknown; isError?: boolean };
+    const toolEvent = event as { toolCallId?: string; toolName?: string; result?: unknown; isError?: boolean; input?: unknown };
     if (typeof toolEvent.toolName !== "string") return;
     const resultText =
       typeof toolEvent.result === "string"
@@ -168,9 +257,12 @@ export function wireRuntime(pi: ExtensionAPI, deps: RuntimeDeps): void {
               return String(toolEvent.result ?? "");
             }
           })();
+    const callId = typeof toolEvent.toolCallId === "string" ? toolEvent.toolCallId : undefined;
+    const input = callId !== undefined ? argsByCallId.get(callId) : undefined;
+    if (callId !== undefined) argsByCallId.delete(callId);
     runaway.feed({
       tool: toolEvent.toolName,
-      input: (event as { input?: unknown }).input,
+      input: input ?? (event as { input?: unknown }).input,
       resultText: resultText.slice(0, 400),
       isError: toolEvent.isError === true,
     });
@@ -202,21 +294,75 @@ export function wireRuntime(pi: ExtensionAPI, deps: RuntimeDeps): void {
     const tokens = sumUsageTokens(messages);
     // Only update when this turn actually reported usage — a usage-less turn
     // keeps the last known counter (and never erases an injected one).
-    if (tokens !== undefined) deps.continuation.setTokenCounter(() => tokens);
+    if (tokens !== undefined) {
+      deps.continuation.setTokenCounter(() => tokens);
+      deps.continuation.setTokensEstimated(false);
+    } else if (messages.length > 0) {
+      // Messages exist but carry no usable usage: estimate from their sizes so
+      // the budget still bounds the loop (flagged as estimated everywhere).
+      const estimated = estimateTokens(messages);
+      deps.continuation.setTokenCounter(() => estimated);
+      deps.continuation.setTokensEstimated(true);
+    }
+    deps.continuation.setNotify((text, level) => {
+      try {
+        (ctx as { ui?: { notify?: (t: string, l?: string) => void } }).ui?.notify?.(text, level ?? "warning");
+      } catch {
+        // Notification must never break settlement.
+      }
+    });
+    if (deps.machine.get()) lastEvidence = activity;
     await deps.continuation.onTurnEnd(activity);
+    // Per-loop goal progress: fire-and-forget, never delays the next turn.
+    if (settings().goalProgress === "loop") void estimateGoal(ctx, true);
     } catch {
       // Settlement failures must never surface as turn aborts.
     }
   });
 
-  // ── verifier evaluate → modelRegistry.complete ──────────────────────
-  const evaluate: VerifierEvaluate = async (prompt, signal) => {
-    const context = evalContext;
+  // ── goal progress estimate (one-off side call, never in context) ─────
+  let lastEvidence: GoalEvidence | undefined;
+  let lastPercent: number | undefined;
+  let lastGoalKey: string | undefined;
+  let estimating = false;
+
+  async function estimateGoal(ctx?: ExtensionContext, fromLoop = false): Promise<"ok" | "none" | "failed"> {
+    try {
+      const goal = deps.machine.get();
+      if (!goal || deps.ralph?.get()?.status === "active") return "none"; // ralph has its own bar
+      const key = `${goal.goalId}:${goal.status}`;
+      const terminal = TERMINAL_GOAL_STATUSES.has(goal.status);
+      // A loop posts once per goal turn; a finished goal posts its last bar once.
+      if (fromLoop && (goal.status === "paused" || (terminal && key === lastGoalKey))) return "none";
+      if (goal.goalId !== lastGoalKey?.split(":")[0]) lastPercent = undefined;
+      lastGoalKey = key;
+      if (goal.status === "complete") {
+        appendProgress(pi, goalProgressData(goal, 100, "Objective met."));
+        return "ok";
+      }
+      if (estimating) return "ok";
+      estimating = true;
+      const s = settings();
+      const text = await complete(s.progressModel || s.verifierModel, goalEstimatePrompt(goal, lastEvidence, lastPercent), undefined, ctx);
+      const est = parseEstimate(text);
+      if (!est) return "failed";
+      lastPercent = est.percent;
+      appendProgress(pi, goalProgressData(deps.machine.get() ?? goal, est.percent, est.summary));
+      return "ok";
+    } catch {
+      return "failed";
+    } finally {
+      estimating = false;
+    }
+  }
+
+  // ── one-shot completions (verifier, progress) → modelRegistry.complete ─
+  async function complete(configured: string, prompt: string, signal?: AbortSignal, ctx?: ExtensionContext): Promise<string> {
+    const context = ctx ? { registry: ctx.modelRegistry, model: ctx.model } : evalContext;
     if (!context?.model || !context.registry) {
       throw new Error("verifier: no model context available yet");
     }
     let model = context.model;
-    const configured = settings().verifierModel;
     if (configured) {
       const slash = configured.indexOf("/");
       if (slash > 0) {
@@ -243,7 +389,8 @@ export function wireRuntime(pi: ExtensionAPI, deps: RuntimeDeps): void {
           : "";
     if (!text) throw new Error("verifier: empty completion");
     return text;
-  };
+  }
+  const evaluate: VerifierEvaluate = (prompt, signal) => complete(settings().verifierModel, prompt, signal);
   deps.continuation.setEvaluate(evaluate);
   if (deps.ralph) deps.ralph.setEvaluate(evaluate);
 
@@ -251,4 +398,11 @@ export function wireRuntime(pi: ExtensionAPI, deps: RuntimeDeps): void {
   pi.on("session_compact", () => {
     deps.continuation.armRecovery();
   });
+  // Boundary compactions (compactor's percentage trigger) don't fire
+  // session_compact; the compactor announces them on the event bus.
+  pi.events?.on?.(UNIPI_EVENTS.COMPACTOR_COMPACTED, () => {
+    deps.continuation.armRecovery();
+  });
+
+  return { estimateGoal: (ctx) => estimateGoal(ctx) };
 }

package/packages/long-horizon/src/settings.ts

@@ -12,7 +12,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
-import { getSettings, registerSettings, setSettings } from "@pi-unipi/core";
+import { decisionModelSection, DEFAULT_DECISION_OVERRIDE, getSettings, registerSettings, resolveDecisionModel, setSettings } from "@pi-unipi/core";
 import type { LhMode } from "./modes.js";
 
 export interface JudgeSettings {
@@ -52,6 +52,14 @@ export interface LongHorizonSettings {
   defaultMode: LhMode;
   /** Model used for goal-completion verification (empty = session model). */
   verifierModel: string;
+  /**
+   * User-only goal progress estimate (a one-off model call, never in context):
+   * "loop" = after every goal turn and on /unipi:goal status; "status" = only
+   * on status; "off" = never.
+   */
+  goalProgress: "loop" | "status" | "off";
+  /** Model for the estimate (empty = verifier model, else session model). */
+  progressModel: string;
 }
 
 export const DEFAULT_SETTINGS: LongHorizonSettings = {
@@ -62,12 +70,14 @@ export const DEFAULT_SETTINGS: LongHorizonSettings = {
     // openrouter/custom ride the decisions endpoint → the hosted jev id.
     model: "typesafe/jev-1.13",
     baseUrl: "",
-    threshold: 0.6,
+    threshold: 0.8,
     timeoutMs: 0,
     apiKey: "",
   },
-  defaultMode: "goal",
+  defaultMode: "none",
   verifierModel: "",
+  goalProgress: "loop",
+  progressModel: "",
 };
 
 const settingsPath = (): string => join(homedir(), ".pi", "agent", "settings.json");
@@ -134,6 +144,8 @@ function mergeSettings(stored: unknown): LongHorizonSettings {
       ? (stored.defaultMode as LhMode)
       : DEFAULT_SETTINGS.defaultMode,
     verifierModel: typeof stored.verifierModel === "string" ? stored.verifierModel : "",
+    goalProgress: stored.goalProgress === "status" || stored.goalProgress === "off" ? stored.goalProgress : "loop",
+    progressModel: typeof stored.progressModel === "string" ? stored.progressModel : "",
   };
 }
 
@@ -145,50 +157,18 @@ let cache: LongHorizonSettings | null = null;
 registerSettings({
   namespace: "long-horizon",
   label: "Long-Horizon",
-  defaults: DEFAULT_SETTINGS as unknown as Record<string, unknown>,
+  defaults: { ...DEFAULT_SETTINGS, decisionModel: DEFAULT_DECISION_OVERRIDE } as unknown as Record<string, unknown>,
   projectOverrides: true,
   schema: [
     {
       title: "Judge",
-      description: "Prompt → mode routing — the transport derives from the model",
+      description: "Prompt → mode routing with the Decision Model (shared settings: /unipi:settings → Decision Model)",
       fields: [
         { key: "judge.enabled", type: "boolean", label: "Judge enabled", description: "Route new prompts automatically; off = always defaultMode" },
-        {
-          key: "judge.provider",
-          type: "enum",
-          label: "Provider",
-          options: [
-            { value: "typesafe", label: "typesafe (native systemone)" },
-            { value: "openrouter", label: "openrouter (decisions endpoint)" },
-            { value: "custom", label: "custom (Base URL + API key)" },
-          ],
-          description: "typesafe = native systemone · openrouter = decisions/chat · custom = your own gateway",
-        },
-        { key: "judge.baseUrl", type: "string", label: "Base URL", description: "required when provider=custom · oino proxy = https://router.oino.dev/v1", emptyLabel: "provider default" },
-        { key: "judge.apiKey", type: "secret", label: "API key", description: "Stored key wins over env (works in tmux/ssh-c/systemd)", emptyLabel: "env / bridge fallback" },
-        {
-          key: "judge.model",
-          type: "model",
-          label: "Decision model",
-          description: "decision (classifier) model — jev; custom… for others",
-          providerKey: "judge.provider",
-          presetsByProvider: {
-            typesafe: ["jev-latest"],
-            openrouter: ["typesafe/jev-1.13"],
-            custom: ["typesafe/jev-1.13"],
-          },
-        },
         { key: "judge.threshold", type: "number", label: "Confidence threshold", description: "Below this the judge abstains (0-1)", min: 0.01, max: 1 },
       ],
     },
-    {
-      title: "Judge — Advanced",
-      advanced: true,
-      description: "Rarely needed — zero means the provider default",
-      fields: [
-        { key: "judge.timeoutMs", type: "number", label: "Timeout ms", min: 0, zeroLabel: "auto (1s native / 6s chat)" },
-      ],
-    },
+    decisionModelSection({ title: "Judge — Decision model" }),
     {
       title: "Modes",
       fields: [
@@ -202,6 +182,24 @@ registerSettings({
         { key: "verifierModel", type: "model", label: "Verifier model", description: "Goal completion verification", emptyLabel: "inherit (session model)", capability: "text", emptyOption: "inherit (session model)" },
       ],
     },
+    {
+      title: "Progress",
+      description: "Progress bars shown only to you — never sent to the model",
+      fields: [
+        {
+          key: "goalProgress",
+          type: "enum",
+          label: "Goal progress estimate",
+          options: [
+            { value: "loop", label: "every loop + /goal status" },
+            { value: "status", label: "only on /goal status" },
+            { value: "off", label: "off" },
+          ],
+          description: "A one-off side call estimates % done and summarizes the work so far",
+        },
+        { key: "progressModel", type: "model", label: "Estimate model", description: "Cheaper is fine; runs once per goal turn", emptyLabel: "inherit (verifier → session model)", capability: "text", emptyOption: "inherit (verifier → session model)" },
+      ],
+    },
   ],
 });
 
@@ -209,10 +207,27 @@ export function loadSettings(force = false): LongHorizonSettings {
   if (cache && !force) return cache;
   const raw = getSettings("long-horizon", process.cwd());
   // The engine stores validated shapes; re-validate defensively anyway.
-  cache = mergeSettings(raw);
+  cache = withDecisionModel(mergeSettings(raw), process.cwd());
   return cache;
 }
 
+/**
+ * The judge's transport (provider/model/baseUrl/key/timeout) is the Decision
+ * Model — shared, or this module's custom override. `enabled` and
+ * `threshold` stay long-horizon's own.
+ */
+function withDecisionModel(settings: LongHorizonSettings, cwd: string): LongHorizonSettings {
+  try {
+    const dm = resolveDecisionModel(cwd, "long-horizon");
+    return {
+      ...settings,
+      judge: { ...settings.judge, provider: dm.provider, model: dm.model, baseUrl: dm.baseUrl, apiKey: dm.apiKey, timeoutMs: dm.timeoutMs ?? 0 },
+    };
+  } catch {
+    return settings;
+  }
+}
+
 export function saveSettings(update: Partial<LongHorizonSettings>): LongHorizonSettings {
   const current = mergeSettings(getSettings("long-horizon", process.cwd()));
   const next = mergeSettings({ ...current, ...update, judge: { ...current.judge, ...(update.judge ?? {}) } });

package/packages/long-horizon/src/tools/goal.ts

@@ -59,6 +59,11 @@ export class GoalToolset {
     return this.pending;
   }
 
+  /** Drop any pending proposal unverified (user stop/clear); get_goal stops advertising it. */
+  discardProposal(): void {
+    this.pending = null;
+  }
+
   register(pi: ExtensionAPI): void {
     // ── create_goal ───────────────────────────────────────────────────
     pi.registerTool({
@@ -219,6 +224,7 @@ export class GoalToolset {
         stall_cap: goal.stallCap,
         token_budget: goal.tokenBudget,
         tokens_used: goal.tokensBaselinePending ? null : goal.tokensNow - goal.tokensAtStart,
+        tokens_estimated: goal.tokensEstimated === true,
         expected_goal_id: goal.goalId,
         expected_updated_at: goal.updatedAt,
         updated_at: goal.updatedAt,

package/packages/long-horizon/src/tools/graph.ts

@@ -51,7 +51,7 @@ export const GRAPH_ORCHESTRATION_PROMPT = `<long-horizon-graph>
 Graph Mode is active. You are the supervisor of a dependent work graph.
 
 - Declare the graph first with update_agent_graph: items with explicit dependsOn (an item's inputs are the COMMITTED results of its dependencies). Cycles are refused.
-- Dispatch every currently-ready item with spawn_helper or bg_delegate. Do not dispatch an item before its dependencies complete.
+- Dispatch every currently-ready item with run_subagent (is_background:true for parallel items). Do not dispatch an item before its dependencies complete.
 - After dispatching a wave, call swarm_yield. Do not poll; background notifications wake you.
 - On wake, record outcomes with graph_output. Recording a completion hands you the next ready items together with their input frontiers (the dependency summaries) — pass those inputs into the child instructions instead of restating conclusions.
 - A failed item can be re-dispatched after its failure is recorded; downstream items stay blocked until it completes or is aborted.

package/packages/long-horizon/src/tools/swarm.ts

@@ -2,12 +2,12 @@
  * Swarm — Maka's fan-out prescription over unipi's delegation tools.
  *
  * The ledger is the durable schedule: declared items with reported outcomes.
- * The MODEL dispatches via spawn_helper/bg_delegate (full surface in swarm
+ * The MODEL dispatches via run_subagent (full surface in swarm
  * mode); swarm_report records outcomes idempotently; swarm_status projects
  * running | needs_attention | settled; swarm_yield ends the supervisor turn
  * (wakes arrive via background-task notifications — user-first by design).
  *
- * v1 seam honesty: spawn_helper dispatch is opaque to extensions, so
+ * v1 seam honesty: run_subagent dispatch is opaque to extensions, so
  * claim-before-dispatch is enforced by the orchestration prompt (one dispatch
  * per item) plus report idempotency (duplicate terminal reports refused
  * unless the item was failed and is being replaced). Harness-level claims
@@ -45,7 +45,7 @@ Swarm Mode is active. Treat parallel delegation as the preferred execution strat
 
 - Before acting, decide whether parallel delegation would materially improve speed, quality, coverage, or independent verification. If the work cannot be usefully divided into at least two meaningful independent items, continue directly.
 - Make every item bounded and self-contained: explicit scope, expected output, constraints. Avoid overlapping writes; prefer read-only investigation.
-- Dispatch each item exactly once with spawn_helper or bg_delegate (run_in_background). Do not re-dispatch an item unless you reported it failed and are replacing it.
+- Dispatch each item exactly once with run_subagent (is_background:true for parallel items). Do not re-dispatch an item unless you reported it failed and are replacing it.
 - After dispatching all items, call swarm_yield. Do not poll, sleep, watch task logs, or wait synchronously; background-task notifications will wake you when work settles.
 - On wake, call swarm_status for compact statuses. Read full results only for completed items you will synthesize or failed items you must diagnose.
 - Record every outcome with swarm_report. Replace failed work by re-dispatching a corrected item and reporting it under the same id.

package/packages/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/mcp",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.21",
   "description": "MCP server management extension for Pi coding agent — browse, add, configure, and use MCP servers",
   "type": "module",
   "main": "src/index.ts",
@@ -30,7 +30,7 @@
     "test": "npx tsx --test tests/**/*.test.ts"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0-alpha.2"
+    "@pi-unipi/core": "3.0.0-alpha.21"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",

package/packages/memory/commands.ts

@@ -11,6 +11,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { sendHarnessUserMessage } from "@pi-unipi/core";
 import type { SessionBackend } from "./session.js";
 import { MEMORY_TOOLS } from "./tools.js";
 import { readMemoryConfig } from "./settings.js";
@@ -226,8 +227,10 @@ export function registerMemoryCommands(
         return;
       }
       ctx.ui.notify("Analyzing text for memories... Use memory_store tool to save.", "info");
-      pi.sendUserMessage(
+      sendHarnessUserMessage(
+        pi,
         `Analyze the following text and extract any memory-worthy items (user preferences, project decisions, code patterns, conversation summaries). For each item found, use the memory_store tool to save it.\n\nText to analyze:\n${args}`,
+        { source: "Memory", title: "Extract memories", synopsis: "Generated from /unipi:memory-process" },
         { deliverAs: "followUp" },
       );
     },
@@ -237,7 +240,8 @@ export function registerMemoryCommands(
     description: "Consolidate current session into memory",
     handler: async (_args, ctx) => {
       ctx.ui.notify("Consolidating session into memory... Use memory_store tool to save insights.", "info");
-      pi.sendUserMessage(
+      sendHarnessUserMessage(
+        pi,
         `Review the current session and identify any memory-worthy items:
 - User preferences discovered
 - Project decisions made
@@ -245,6 +249,7 @@ export function registerMemoryCommands(
 - Important context to remember
 
 For each item, use the memory_store tool to save it with an appropriate title and type.`,
+        { source: "Memory", title: "Consolidate session", synopsis: "Generated from /unipi:memory-consolidate" },
         { deliverAs: "followUp" },
       );
     },