@pi-unipi/unipi 3.0.0 → 3.0.1

package/packages/core/src/settings/snapshot.ts

@@ -0,0 +1,247 @@
+/**
+ * Settings snapshot — the settings catalog published to disk for OTHER
+ * processes (the unipi-host serves it to the app's Settings → UniPi screen;
+ * docs: `~/.unipi/config/settings-schema.json`).
+ *
+ * `buildSettingsSnapshot()` flattens the live registry (engine.ts) into plain
+ * JSON: getters are resolved (order items, page sections), functions are
+ * dropped (`validate` → `validated: true`, model `filter` → `filtered: true`),
+ * and anything that throws while reading is skipped — a broken getter in one
+ * module must never blank the whole catalog.
+ */
+
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { listSettingsDefinitions, type SettingsDefinition } from "./engine.js";
+import { unipiConfigRoot } from "./paths.js";
+import { enumOption, type SettingsField, type SettingsSection } from "./schema.js";
+
+export interface SettingsSnapshotNamespace {
+  readonly namespace: string;
+  readonly label: string;
+  readonly defaults: Record<string, unknown>;
+  readonly projectOverrides: boolean;
+  /** The module mirrors writes into another program's config (an `onSet` hook) — the host cannot run it, so the app must not write these. */
+  readonly mirrored: boolean;
+  readonly sections: readonly SettingsSnapshotSection[];
+}
+
+export interface SettingsSnapshotSection {
+  readonly title: string;
+  readonly description?: string;
+  readonly advanced?: boolean;
+  readonly fields: readonly SnapshotField[];
+}
+
+/** A field as plain JSON — no functions; getters already resolved. */
+export type SnapshotField =
+  | ({ readonly key: string; readonly type: "boolean"; readonly label: string; readonly description?: string; readonly scopes?: readonly string[] } & Validated)
+  | ({ readonly key: string; readonly type: "enum"; readonly label: string; readonly description?: string; readonly scopes?: readonly string[]; readonly options: readonly { readonly value: string; readonly label: string; readonly description?: string }[]; readonly plainOptions?: boolean; readonly allowCustom?: boolean; readonly hint?: string; readonly scope?: "global"; readonly clearable?: boolean } & Validated)
+  | ({ readonly key: string; readonly type: "string" | "secret"; readonly label: string; readonly description?: string; readonly scopes?: readonly string[]; readonly emptyLabel?: string; readonly hint?: string } & Validated)
+  | ({ readonly key: string; readonly type: "number"; readonly label: string; readonly description?: string; readonly scopes?: readonly string[]; readonly min?: number; readonly max?: number; readonly unit?: string; readonly zeroLabel?: string; readonly hint?: string } & Validated)
+  | ({ readonly key: string; readonly type: "model"; readonly label: string; readonly description?: string; readonly scopes?: readonly string[]; readonly provider?: string; readonly capability?: string; readonly emptyLabel?: string; readonly presets?: readonly string[]; readonly presetsByProvider?: Readonly<Record<string, readonly string[]>>; readonly emptyOption?: string; readonly providerKey?: string; readonly filtered?: boolean } & Validated)
+  | ({ readonly key: string; readonly type: "multiselect"; readonly label: string; readonly description?: string; readonly scopes?: readonly string[]; readonly options: readonly { readonly value: string; readonly label: string; readonly description?: string }[]; readonly plainOptions?: boolean; readonly emptyLabel?: string } & Validated)
+  | ({ readonly key: string; readonly type: "order"; readonly label: string; readonly description?: string; readonly scopes?: readonly string[]; readonly items: readonly { readonly value: string; readonly label: string }[] } & Validated)
+  | ({ readonly key: string; readonly type: "page"; readonly label: string; readonly description?: string; readonly scopes?: readonly string[]; readonly sections: readonly SettingsSnapshotSection[] } & Validated)
+  | ({ readonly key: string; readonly type: "action"; readonly label: string; readonly description?: string; readonly scopes?: readonly string[]; readonly command: string } & Validated);
+
+/** The raw-input validation gate stays in pi; the flag says input beyond the type checks is pi-validated. */
+interface Validated {
+  readonly validated?: boolean;
+}
+
+export interface SettingsSnapshot {
+  readonly version: 1;
+  readonly writtenAt: string;
+  /** Best-effort: the @pi-unipi/core package version, when resolvable. */
+  readonly unipiVersion?: string;
+  readonly namespaces: readonly SettingsSnapshotNamespace[];
+}
+
+/** The core package's version, read once (best-effort — a bundled install may not carry package.json). */
+function coreVersion(): string | undefined {
+  try {
+    const pkg = new URL("../../package.json", import.meta.url);
+    const parsed = JSON.parse(readFileSync(fileURLToPath(pkg), "utf8")) as { version?: unknown };
+    return typeof parsed.version === "string" ? parsed.version : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Serialise one field; `undefined` = skip it (a getter threw / unknown shape). */
+function snapshotField(field: SettingsField): SnapshotField | undefined {
+  const base = {
+    key: field.key,
+    label: field.label,
+    ...(field.description !== undefined ? { description: field.description } : {}),
+    ...(field.scopes !== undefined ? { scopes: [...field.scopes] } : {}),
+    // validate stays in pi; the flag keeps the fact visible in the catalog.
+    validated: "validate" in field && typeof field.validate === "function",
+  };
+  try {
+    switch (field.type) {
+      case "boolean":
+        return { ...base, type: "boolean" };
+      case "enum":
+        return {
+          ...base,
+          type: "enum",
+          options: field.options.map(enumOption),
+          ...(field.plainOptions !== undefined ? { plainOptions: field.plainOptions } : {}),
+          ...(field.allowCustom !== undefined ? { allowCustom: field.allowCustom } : {}),
+          ...(field.hint !== undefined ? { hint: field.hint } : {}),
+          ...(field.scope !== undefined ? { scope: field.scope } : {}),
+          ...(field.clearable !== undefined ? { clearable: field.clearable } : {}),
+        };
+      case "string":
+      case "secret":
+        return {
+          ...base,
+          type: field.type,
+          ...(field.emptyLabel !== undefined ? { emptyLabel: field.emptyLabel } : {}),
+          ...(field.hint !== undefined ? { hint: field.hint } : {}),
+        };
+      case "number":
+        return {
+          ...base,
+          type: "number",
+          ...(field.min !== undefined ? { min: field.min } : {}),
+          ...(field.max !== undefined ? { max: field.max } : {}),
+          ...(field.unit !== undefined ? { unit: field.unit } : {}),
+          ...(field.zeroLabel !== undefined ? { zeroLabel: field.zeroLabel } : {}),
+          ...(field.hint !== undefined ? { hint: field.hint } : {}),
+        };
+      case "model":
+        return {
+          ...base,
+          type: "model",
+          ...(field.provider !== undefined ? { provider: field.provider } : {}),
+          ...(field.capability !== undefined ? { capability: field.capability } : {}),
+          ...(field.emptyLabel !== undefined ? { emptyLabel: field.emptyLabel } : {}),
+          ...(field.presets !== undefined ? { presets: [...field.presets] } : {}),
+          ...(field.presetsByProvider !== undefined
+            ? { presetsByProvider: Object.fromEntries(Object.entries(field.presetsByProvider).map(([k, v]) => [k, [...v]])) }
+            : {}),
+          ...(field.emptyOption !== undefined ? { emptyOption: field.emptyOption } : {}),
+          ...(field.providerKey !== undefined ? { providerKey: field.providerKey } : {}),
+          // The filter is a function; only the fact that the catalog is filtered survives.
+          ...(field.filter !== undefined ? { filtered: true } : {}),
+        };
+      case "multiselect":
+        return {
+          ...base,
+          type: "multiselect",
+          options: field.options.map(enumOption),
+          ...(field.plainOptions !== undefined ? { plainOptions: field.plainOptions } : {}),
+          ...(field.emptyLabel !== undefined ? { emptyLabel: field.emptyLabel } : {}),
+        };
+      case "order":
+        // Resolve the universe now: the host/app must not need the module.
+        return { ...base, type: "order", items: field.items().map((i) => ({ value: i.value, label: i.label })) };
+      case "page":
+        // Resolve the sections getter now; nested pages recurse, summary stays pi-side.
+        return { ...base, type: "page", sections: snapshotSections(typeof field.sections === "function" ? field.sections() : field.sections) };
+      case "action":
+        return { ...base, type: "action", command: field.command };
+      default:
+        return undefined;
+    }
+  } catch {
+    // A throwing getter (order items, page sections) skips just this field.
+    return undefined;
+  }
+}
+
+function snapshotSection(section: SettingsSection): SettingsSnapshotSection | undefined {
+  try {
+    const fields: SnapshotField[] = [];
+    for (const field of section.fields) {
+      const snap = snapshotField(field);
+      if (snap) fields.push(snap);
+    }
+    return {
+      title: section.title,
+      ...(section.description !== undefined ? { description: section.description } : {}),
+      ...(section.advanced !== undefined ? { advanced: section.advanced } : {}),
+      fields,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function snapshotSections(sections: readonly SettingsSection[]): SettingsSnapshotSection[] {
+  const out: SettingsSnapshotSection[] = [];
+  for (const section of sections) {
+    const snap = snapshotSection(section);
+    if (snap) out.push(snap);
+  }
+  return out;
+}
+
+function snapshotNamespace(definition: SettingsDefinition): SettingsSnapshotNamespace {
+  return {
+    namespace: definition.namespace,
+    label: definition.label,
+    defaults: definition.defaults,
+    projectOverrides: definition.projectOverrides !== false,
+    mirrored: typeof definition.onSet === "function",
+    sections: snapshotSections(definition.schema ?? []),
+  };
+}
+
+/** Flatten the live settings registry into plain, getter-free JSON. */
+export function buildSettingsSnapshot(): SettingsSnapshot {
+  const version = coreVersion();
+  return {
+    version: 1,
+    writtenAt: new Date().toISOString(),
+    ...(version !== undefined ? { unipiVersion: version } : {}),
+    namespaces: listSettingsDefinitions().map(snapshotNamespace),
+  };
+}
+
+const SNAPSHOT_FILE = "settings-schema.json";
+
+/**
+ * Publish the snapshot to `~/.unipi/config/settings-schema.json` — atomically
+ * (tmp + rename), and only when the content other than `writtenAt` changed
+ * (a clock-only diff must not dirty the file on every session start). Never
+ * throws: publishing is best-effort by design.
+ */
+export function writeSettingsSnapshot(): void {
+  try {
+    const snapshot = buildSettingsSnapshot();
+    const file = joinPath(unipiConfigRoot(), SNAPSHOT_FILE);
+    mkdirSync(dirname(file), { recursive: true });
+    const previous = readPrevious(file);
+    if (previous && sameExceptWrittenAt(previous, snapshot)) return;
+    const tmp = `${file}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(snapshot, null, 2)}\n`);
+    renameSync(tmp, file);
+  } catch {
+    // Best-effort: no snapshot, no crash.
+  }
+}
+
+function joinPath(root: string, file: string): string {
+  return root.endsWith("/") ? `${root}${file}` : `${root}/${file}`;
+}
+
+function readPrevious(file: string): SettingsSnapshot | undefined {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8")) as SettingsSnapshot;
+    return parsed && typeof parsed === "object" ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Everything except `writtenAt` must be equal to skip the rewrite. */
+function sameExceptWrittenAt(a: SettingsSnapshot, b: SettingsSnapshot): boolean {
+  const { writtenAt: _a, ...restA } = a as SettingsSnapshot & { writtenAt?: string };
+  const { writtenAt: _b, ...restB } = b as SettingsSnapshot & { writtenAt?: string };
+  return JSON.stringify(restA) === JSON.stringify(restB);
+}

package/packages/dream/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/dream",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "A pi extension that dreams: reviews past session struggles in the background, turns repeated false paths into memory lessons, and crafts skills from errors — part of the Unipi suite",
   "type": "module",
   "main": "extensions/dream.ts",
@@ -39,7 +39,7 @@
     "@earendil-works/pi-tui": "^0.87.1"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0"
+    "@pi-unipi/core": "3.0.1"
   },
   "pi": {
     "extensions": [

package/packages/footer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/footer",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Persistent status bar for Unipi — subscribes to UNIPI_EVENTS and renders key stats from all unipi packages",
   "type": "module",
   "main": "index.ts",
@@ -32,8 +32,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0",
-    "@pi-unipi/background-tasks": "3.0.0"
+    "@pi-unipi/core": "3.0.1",
+    "@pi-unipi/background-tasks": "3.0.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",

package/packages/fusion/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/fusion",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Devin-style model picker, fusion presets (lead + sidekick), and Local Fusion runtime for UniPi",
   "type": "module",
   "main": "src/index.ts",
@@ -32,9 +32,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0",
-    "@pi-unipi/subagents": "3.0.0",
-    "@pi-unipi/utility": "3.0.0"
+    "@pi-unipi/core": "3.0.1",
+    "@pi-unipi/subagents": "3.0.1",
+    "@pi-unipi/utility": "3.0.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.87.1",

package/packages/info-screen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/info-screen",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Unicrab startup splash and the /unipi:info dashboard — this session, context, usage, compaction savings",
   "type": "module",
   "main": "index.ts",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0"
+    "@pi-unipi/core": "3.0.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",

package/packages/input-shortcuts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/input-shortcuts",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Keyboard shortcuts for stash/restore, undo/redo, clipboard, and thinking toggle — chord-based overlay system",
   "type": "module",
   "main": "src/index.ts",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0"
+    "@pi-unipi/core": "3.0.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",

package/packages/kanboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/kanboard",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Kanboard v3 — deferred-work board: CLI/daemon bridge, task runner and skill",
   "type": "module",
   "main": "index.ts",
@@ -31,7 +31,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0"
+    "@pi-unipi/core": "3.0.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",
@@ -48,10 +48,10 @@
     "themes": []
   },
   "optionalDependencies": {
-    "@pi-unipi/kanboard-linux-x64": "3.0.0",
-    "@pi-unipi/kanboard-linux-arm64": "3.0.0",
-    "@pi-unipi/kanboard-darwin-x64": "3.0.0",
-    "@pi-unipi/kanboard-darwin-arm64": "3.0.0",
-    "@pi-unipi/kanboard-win32-x64": "3.0.0"
+    "@pi-unipi/kanboard-linux-x64": "3.0.1",
+    "@pi-unipi/kanboard-linux-arm64": "3.0.1",
+    "@pi-unipi/kanboard-darwin-x64": "3.0.1",
+    "@pi-unipi/kanboard-darwin-arm64": "3.0.1",
+    "@pi-unipi/kanboard-win32-x64": "3.0.1"
   }
 }

package/packages/long-horizon/README.md

@@ -111,9 +111,7 @@ Next comes the active owner, then the judge, then `defaultMode`. The gate adds
 the mode prompt and filters the tool list. Within one mode, the tool list stays
 the same, so the prefix cache stays valid.
 
-The engine keeps owner state in `~/.unipi/workspace/<id>/state/long-horizon/`.
-Ralph checklists are in the `ralph/` folder there. Owners do not start inside a
-child agent.
+The engine keeps owner state in `~/.unipi/workspace/<id>/state/long-horizon/sessions/<sessionId>/` — a run belongs to the session that started it, so a new session starts clean (it gets a one-line note when another session holds a live graph; resuming the owning session continues it, and the first resume of the owning session picks up pre-3.0.1 runs). Ralph checklists are in the `ralph/` folder there. Owners do not start inside a child agent.
 
 Read [Long-horizon architecture](../../docs/architecture/long-horizon.md) and
 [Turn arbiter](../../docs/architecture/turn-arbiter.md).

package/packages/long-horizon/index.ts

@@ -28,6 +28,22 @@ import { countStatuses, GraphEngine, type GraphMode } from "./src/graph/engine.j
 import { graphRunnerFromPort, readGraphRunPort } from "./src/graph/runner.js";
 import { TodoStore, registerTodoTool } from "./src/tools/todo.js";
 import { wireRuntime } from "./src/runtime.js";
+import {
+  adoptLegacyState,
+  legacyOwnershipEvidence,
+  graphUpdatedAt as graphUpdatedAtFallback,
+  aggregateGraphHistory,
+  findSiblingWork,
+  graphOwnerNote,
+  isContinuedSession,
+  legacyInRepoDir,
+  legacyWorkspaceDir,
+  pruneSiblingSessionDirs,
+  scanSiblingGraphOwners,
+  sessionHasState,
+  sessionStateDir,
+  type SiblingGraphOwner,
+} from "./src/session-state.js";
 import { ralphProgressData } from "./src/progress.js";
 import { lhProgressSnapshot, sameProgress, withProgressLog, type ProgressGoalEstimate } from "./src/progress-snapshot.js";
 import { registerVisualizeProgress } from "./src/visualize.js";
@@ -44,19 +60,21 @@ const LH_DIR = ".unipi/long-horizon";
  * if the new file is absent but the legacy in-repo <cwd>/.unipi/long-horizon/
  * file exists, move it over on first access.
  */
+/**
+ * UNI-followup: a run belongs to the session that started it — the dir is
+ * `.../long-horizon/sessions/<sessionId>/` once session_start has stamped
+ * `currentSessionId` (before that, pre-session access still lands in the
+ * legacy workspace-level dir). The legacy workspace-level files and the
+ * older in-repo `.unipi/long-horizon/` files are adopted into the session
+ * dir at session_start (continued sessions only, see the adoption there).
+ */
+let currentSessionId: string | undefined;
+const workspaceStateDir = (): string => stateDir("long-horizon", "state");
+const lhSessionsDir = (): string => join(workspaceStateDir(), "sessions");
+
 function lhStatePath(file: string): string {
-  const dest = join(stateDir("long-horizon", "state"), file);
-  if (!existsSync(dest)) {
-    const legacy = join(resolve(process.cwd()), LH_DIR, file);
-    if (existsSync(legacy)) {
-      try {
-        renameSync(legacy, dest);
-      } catch {
-        // Fall through: a failed move just means we start fresh at dest.
-      }
-    }
-  }
-  return dest;
+  const dir = currentSessionId ? sessionStateDir(workspaceStateDir(), currentSessionId) : workspaceStateDir();
+  return join(dir, file);
 }
 
 export default function longHorizon(pi: ExtensionAPI): void {
@@ -126,8 +144,10 @@ export default function longHorizon(pi: ExtensionAPI): void {
   }
   // Bound once the graph engine exists (owner events can fire before that).
   let graphOwnerChanged: ((event: OwnerEvent) => void) | undefined;
+  const sessionInfo: { id?: string; name?: string; pid?: number } = {};
   const owner = new OwnerCoordinator({
     statePath,
+    session: () => sessionInfo,
     onChange: (_snapshot, event: OwnerEvent) => {
       // Owner transitions sync pi's active set (UNI-90): activate/resume/restore
       // outside before_agent_start must expose the owner's mode tools at once.
@@ -567,8 +587,56 @@ export default function longHorizon(pi: ExtensionAPI): void {
   // reattaches the owner's tool surface; the continuation arms a recovery
   // fragment for the first post-restart turn.
   pi.on("session_start", (event, ctx) => {
-    // A sticky mode belongs to the session that picked it (UNI-165).
+    // UNI-followup: stamp the session id FIRST — every lhStatePath() read below
+    // (restore/bind) must land in THIS session's dir before any restore runs.
     const reason = (event as { reason?: string } | undefined)?.reason;
+    const manager = (ctx as { sessionManager?: { getSessionId?: () => string; getEntries?: () => unknown[] } } | undefined)?.sessionManager;
+    try {
+      currentSessionId = manager?.getSessionId?.();
+    } catch {
+      // Keep the legacy workspace dir when the id is unavailable.
+    }
+    sessionInfo.id = currentSessionId;
+    try {
+      const name = (pi as unknown as { getSessionName?: () => string | undefined }).getSessionName?.();
+      if (name) sessionInfo.name = name;
+    } catch {
+      // Name is cosmetic.
+    }
+    sessionInfo.pid = process.pid;
+    const priorEntries = (() => {
+      try {
+        return manager?.getEntries?.().length ?? 0;
+      } catch {
+        return 0;
+      }
+    })();
+    const continued = isContinuedSession(reason, priorEntries);
+
+    // Legacy adoption (continued sessions only, and only when THIS session's
+    // own transcript proves it owned the run — the entries must contain the
+    // legacy graph id / goal id / objective / loop name). Otherwise the files
+    // stay put: an unrelated `pi -r` must not adopt (and drive) someone's
+    // graph — that would re-introduce the cross-session wake bug. The
+    // sibling-owner note still points the user at it.
+    const legacyDirs = [legacyWorkspaceDir(workspaceStateDir()), legacyInRepoDir(resolve(process.cwd()))];
+    const entriesJson = (() => {
+      try {
+        return JSON.stringify(manager?.getEntries?.() ?? []);
+      } catch {
+        return "";
+      }
+    })();
+    const legacyEvidence = continued && !sessionHasState(sessionStateDir(workspaceStateDir(), currentSessionId ?? ""))
+      ? legacyOwnershipEvidence(entriesJson, legacyDirs)
+      : false;
+        if (continued && legacyEvidence && !sessionHasState(sessionStateDir(workspaceStateDir(), currentSessionId ?? ""))) {
+      adoptLegacyState(sessionStateDir(workspaceStateDir(), currentSessionId ?? ""), legacyDirs, ["state.json", "goal.json", "graph.json"]);
+    }
+    // Housekeeping: siblings with no owner, no open graph, >30 days old.
+    if (currentSessionId) pruneSiblingSessionDirs(lhSessionsDir(), currentSessionId, Date.now());
+
+    // A sticky mode belongs to the session that picked it (UNI-165).
     if (reason === "new" || reason === "resume" || reason === "fork") gate.dropStickyWorkMode();
     // Mode tools start OFF; a restored active owner re-syncs them ON below.
     gate.resetModeTools();
@@ -601,10 +669,10 @@ export default function longHorizon(pi: ExtensionAPI): void {
     // otherwise the recovery fragment rides the next continuation.
     const goalStatus = machine.get()?.status;
     if (goalStatus === "active" || goalStatus === "waiting") {
-      // Goal state is workspace-keyed: a /new or forked session must not be
-      // driven by another session's undelivered prompt (fragment only).
-      // Print mode (no UI) owns its own prompt: never race it with a wake.
-      const redeliver = !isChildProcess() && reason !== "new" && reason !== "fork" && (ctx as { hasUI?: boolean } | undefined)?.hasUI !== false;
+      // State is session-scoped, so this is always THIS session's pending
+      // continuation. Print mode (no UI) owns its own prompt: never race it
+      // with a wake.
+      const redeliver = !isChildProcess() && (ctx as { hasUI?: boolean } | undefined)?.hasUI !== false;
       const recovery = redeliver ? continuation.recoverOnRestart() : (continuation.armRecovery(), undefined);
       if (recovery?.action === "redeliver") {
         // Outside any turn: a direct wake once startup has finished.
@@ -614,6 +682,21 @@ export default function longHorizon(pi: ExtensionAPI): void {
         }, 0);
       }
     }
+    // UNI-followup: one-line note when another session holds a live graph —
+    // never reaches the model (ui.notify is user-only) and never starts a turn.
+    if (!isChildProcess() && (reason === "new" || reason === "fork" || reason === "startup" || reason === undefined) && (ctx as { hasUI?: boolean } | undefined)?.hasUI) {
+      try {
+        const siblings = scanSiblingGraphOwners(lhSessionsDir(), currentSessionId ?? "", legacyWorkspaceDir(workspaceStateDir()), legacyInRepoDir(resolve(process.cwd())))
+          .filter((o: SiblingGraphOwner) => o.sessionId !== currentSessionId);
+        const note = graphOwnerNote(siblings[0]);
+        if (note) {
+          const ui = (ctx as { ui?: { notify?: (message: string, level?: string) => void } }).ui;
+          ui?.notify?.(note, "info");
+        }
+      } catch {
+        // The note is best-effort; a failed scan must not break startup.
+      }
+    }
     // Resume (`pi -r`) starts no turn, so before_agent_start never fires.
     // Publish unconditionally so the header restores without depending on a
     // one-shot event beating the footer's subscription.
@@ -627,8 +710,17 @@ export default function longHorizon(pi: ExtensionAPI): void {
     const a = (args ?? {}) as { op?: unknown; id?: unknown; graphId?: unknown };
     const op = String(a.op ?? "");
     if (op === "output") {
-      const found = graphEngine.readResult(String(a.id ?? ""), typeof a.graphId === "string" ? a.graphId : undefined);
-      if (!found) return { ok: false, reason: "That step is gone." };
+      const graphId = typeof a.graphId === "string" ? a.graphId : undefined;
+      const found = graphEngine.readResult(String(a.id ?? ""), graphId);
+      // UNI-followup: history spans the project — find results in sibling
+      // sessions' FINISHED graphs too (read-only; never an open graph).
+      const sibling = !found && graphId && currentSessionId ? findSiblingWork(lhSessionsDir(), currentSessionId, graphId, String(a.id ?? "")) : undefined;
+      if (!found) {
+        if (!sibling) return { ok: false, reason: "That step is gone." };
+        const w = sibling.work as { workId?: unknown; status?: unknown; resultId?: unknown; operatorId?: unknown; instruction?: unknown; result?: unknown; failure?: unknown; resultTruncated?: unknown };
+        return { ok: true, output: { graphId, id: String(w.workId ?? a.id ?? ""), status: String(w.status ?? ""), ...(w.resultId ? { resultId: w.resultId } : {}), ...(w.operatorId ? { operatorId: w.operatorId } : {}), instruction: String(w.instruction ?? ""), ...(w.result ? { text: w.result } : {}), ...(w.failure ? { failure: w.failure } : {}), ...(w.resultTruncated ? { truncated: true } : {}) } };
+      }
+      // This session's own copy (authoritative).
       const w = found.work;
       return { ok: true, output: { graphId: found.graphId, id: w.workId, status: w.status, ...(w.resultId ? { resultId: w.resultId } : {}), ...(w.operatorId ? { operatorId: w.operatorId } : {}), instruction: w.instruction, ...(w.result ? { text: w.result } : {}), ...(w.failure ? { failure: w.failure } : {}), ...(w.resultTruncated ? { truncated: true } : {}) } };
     }
@@ -640,14 +732,26 @@ export default function longHorizon(pi: ExtensionAPI): void {
       return { ok: true };
     }
     if (op === "history") {
-      const runs = graphEngine.history().slice(0, 20).map((g) =>
-        lhProgressSnapshot({
-          finished: { kind: g.mode, label: g.task, terminalReason: g.finish ? "complete(finish)" : (g.abandoned?.reason ?? "stopped"), endedAt: new Date(g.finish?.at ?? g.abandoned?.at ?? g.updatedAt).toISOString() },
-          graph: g,
-          graphEngine,
-          now: Date.now(),
-        }).last,
-      ).filter((run) => run !== undefined);
+      // UNI-followup: the project's graph history — this engine's own history
+      // plus siblings' FINISHED graphs (history entries and a closed current;
+      // never another session's open graph), deduped by graphId, newest first.
+      const aggregate = currentSessionId
+        ? aggregateGraphHistory(graphEngine.history().map((g) => g as unknown as Record<string, unknown> & { graphId?: string }), lhSessionsDir(), currentSessionId)
+        : graphEngine.history().map((g) => g as unknown as Record<string, unknown> & { graphId?: string });
+      const runs = aggregate
+        .slice(0, 20)
+        .map((g) => {
+          const graph = g as unknown as Parameters<typeof lhProgressSnapshot>[0]["graph"];
+          const finish = g["finish"] as { at?: number } | undefined;
+          const abandoned = g["abandoned"] as { reason?: string; at?: number } | undefined;
+          return lhProgressSnapshot({
+            finished: { kind: (g["mode"] as "graph" | "swarm"), label: String(g["task"] ?? ""), terminalReason: finish ? "complete(finish)" : (abandoned?.reason ?? "stopped"), endedAt: new Date(finish?.at ?? abandoned?.at ?? graphUpdatedAtFallback(g)).toISOString() },
+            graph,
+            graphEngine,
+            now: Date.now(),
+          }).last;
+        })
+        .filter((run) => run !== undefined);
       return { ok: true, runs };
     }
     return { ok: false, reason: `unknown op "${op}"` };

package/packages/long-horizon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/long-horizon",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Long-horizon execution for Pi — mode-gated /goal /ralph /swarm /graph orchestration with a TypeSafe prompt judge",
   "type": "module",
   "main": "index.ts",
@@ -37,7 +37,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0",
+    "@pi-unipi/core": "3.0.1",
     "@resvg/resvg-wasm": "^2.6.2",
     "beautiful-mermaid": "^1.1.3"
   },