@pi-unipi/unipi 3.0.0 → 3.0.1

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

@@ -37,6 +37,14 @@ export interface OwnerState {
   readonly revision: number;
   readonly lease: OwnerLease;
   readonly updatedAt: string;
+  /**
+   * UNI-followup: the session that started/adopted this run — state is
+   * session-scoped, so these are informational (the other-session warning).
+   */
+  readonly sessionId?: string;
+  readonly sessionName?: string;
+  /** Refreshed on restore/bind so "running vs paused" is honest. */
+  readonly pid?: number;
 }
 
 export interface OwnerHistoryEntry {
@@ -57,7 +65,9 @@ export interface OwnerSnapshot {
 export interface OwnerCoordinatorDeps {
   /** Absolute path of the state file (usually under .unipi/long-horizon/). */
   statePath(): string;
-  now?(): number;
+  now?(): number
+  /** The current session's identity, stamped onto activated/adopted owners. */
+  session?(): { id?: string; name?: string; pid?: number };
   /** Best-effort observer; failures never roll back a committed transition. */
   onChange?(snapshot: OwnerSnapshot, event: OwnerEvent): void;
 }
@@ -130,6 +140,7 @@ export class OwnerCoordinator {
     if (this.active) return undefined;
     const ownerId = randomUUID();
     const now = new Date(this.deps.now?.() ?? Date.now()).toISOString();
+    const session = this.deps.session?.();
     const owner: OwnerState = Object.freeze({
       ownerId,
       kind,
@@ -138,6 +149,9 @@ export class OwnerCoordinator {
       revision: 0,
       lease: Object.freeze({ ownerId, generation: 0 }),
       updatedAt: now,
+      ...(session?.id ? { sessionId: session.id } : {}),
+      ...(session?.name ? { sessionName: session.name } : {}),
+      ...(session?.pid ? { pid: session.pid } : {}),
     });
     this.active = owner;
     return this.commit({ type: "activated", owner });
@@ -229,6 +243,24 @@ export class OwnerCoordinator {
         // Corrupt state is treated as absent: repair, don't resurrect.
       }
     }
+    // UNI-followup: adopt (stamp the session id on a legacy owner with none)
+    // and refresh the pid — the owning process is here again. An owner stamped
+    // with ANOTHER session id never happens on disk (state is session-scoped).
+    const session = this.deps.session?.();
+    const refresh = (owner: OwnerState | undefined): OwnerState | undefined => {
+      if (!owner) return owner;
+      // Adopt: a legacy owner without a session stamp belongs to whoever
+      // restores it first (the continued-session rule gated this already).
+      const stamp = owner.sessionId === undefined && session?.id ? { sessionId: session.id } : {};
+      const nameInfo = !owner.sessionName && session?.name ? { sessionName: session.name } : {};
+      const pidInfo = session?.pid !== undefined && owner.pid !== session.pid ? { pid: session.pid } : {};
+      if (!("sessionId" in stamp) && !("sessionName" in nameInfo) && !("pid" in pidInfo)) return owner;
+      const next = this.withOwner(owner, { ...stamp, ...nameInfo, ...pidInfo });
+      this.persist();
+      return next;
+    };
+    if (this.active) this.active = refresh(this.active);
+    if (this.parked) this.parked = refresh(this.parked);
     const snapshot = this.snapshot();
     this.deps.onChange?.(snapshot, { type: "restored", snapshot });
     return snapshot;

package/packages/long-horizon/src/session-state.ts

@@ -0,0 +1,366 @@
+/**
+ * Session-scoped long-horizon state — a run belongs to the session that
+ * started it (UNI-followup): every session reads/writes
+ * `~/.unipi/workspace/<id>/state/long-horizon/sessions/<sessionId>/`, so a
+ * `/new` or app "New chat" starts clean instead of adopting (and waking)
+ * another session's graph.
+ *
+ * Pure helpers here (testable without pi): path layout, the "is this a
+ * continued session" rule, adoption of legacy pre-split state, sibling
+ * scans for the one-line warning and the read-only history aggregate, and
+ * the >30-days housekeeping prune.
+ */
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+/** Files (and the ralph dir) that make up one session's long-horizon state. */
+export const LH_SESSION_FILES = ["state.json", "goal.json", "graph.json"] as const;
+
+/** `<workspace state>/long-horizon/sessions/<sessionId>/` — one dir per session. */
+export function sessionStateDir(workspaceStateDir: string, sessionId: string): string {
+  return join(workspaceStateDir, "sessions", sessionId);
+}
+
+/** The pre-split workspace-level dir (legacy, adopted once by a continued session). */
+export function legacyWorkspaceDir(workspaceStateDir: string): string {
+  return workspaceStateDir;
+}
+
+/** The older in-repo legacy dir (`<cwd>/.unipi/long-horizon`). */
+export function legacyInRepoDir(cwd: string): string {
+  return join(cwd, ".unipi", "long-horizon");
+}
+
+/**
+ * A continued session keeps what its project was doing: `resume`/`reload`
+ * explicitly, and a bare `startup` counts when the session file already has
+ * entries (pi -r replays them). `new`/`fork` and an entry-less startup start
+ * clean and never adopt.
+ */
+export function isContinuedSession(reason: string | undefined, priorEntryCount: number): boolean {
+  if (reason === "resume" || reason === "reload") return true;
+  if (reason === "new" || reason === "fork") return false;
+  return priorEntryCount > 0;
+}
+
+/**
+ * Does THIS session's own transcript prove it owned the legacy run? The
+ * entries (stringified) must contain, for a graph/swarm owner, the legacy
+ * graph's `current.graphId`; for a goal owner, the goal's id or objective;
+ * for a ralph owner, the loop name. Without that, an unrelated `pi -r` of
+ * some other session must NOT adopt (and then drive) the legacy run — that
+ * would re-introduce exactly the cross-session wake bug. The sibling-owner
+ * note still tells the user where the run lives.
+ */
+export function legacyOwnershipEvidence(entriesJson: string, legacyDirs: string[]): boolean {
+  if (!entriesJson) return false;
+  for (const dir of legacyDirs) {
+    const state = readOwnerState(join(dir, "state.json"));
+    const owner = state?.active ?? state?.parked;
+    const kind = owner?.kind;
+    if (kind === "graph" || kind === "swarm") {
+      try {
+        const graph = JSON.parse(readJsonFile(join(dir, "graph.json"))) as { current?: { graphId?: string } };
+        const graphId = graph?.current?.graphId;
+        if (graphId && entriesJson.includes(graphId)) return true;
+      } catch {
+        // No/bad graph.json: no graph evidence from this dir.
+      }
+    } else if (kind === "goal") {
+      try {
+        const goal = JSON.parse(readJsonFile(join(dir, "goal.json"))) as { goalId?: string; objective?: string };
+        if ((goal?.goalId && entriesJson.includes(goal.goalId)) || (goal?.objective && entriesJson.includes(goal.objective))) return true;
+      } catch {
+        // No/bad goal.json.
+      }
+    } else if (kind === "ralph") {
+      const loopName = owner?.label;
+      if (loopName && entriesJson.includes(loopName)) return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Move legacy state (workspace-level and in-repo) into the session dir.
+ * Only files the session dir lacks are moved; rename is atomic; the first
+ * continued session wins (the source is gone afterwards). Returns what moved.
+ */
+export function adoptLegacyState(sessionDir: string, sources: string[], files: readonly string[]): string[] {
+  const moved: string[] = [];
+  if (existsSync(join(sessionDir, "state.json"))) return moved;
+  try {
+    mkdirSync(sessionDir, { recursive: true });
+  } catch {
+    return moved;
+  }
+  for (const source of sources) {
+    for (const file of files) {
+      const from = join(source, file);
+      const to = join(sessionDir, file);
+      if (!existsSync(to) && existsSync(from)) {
+        try {
+          renameSync(from, to);
+          moved.push(from);
+        } catch {
+          // A failed move just means this session starts fresh at `to`.
+        }
+      }
+    }
+    // The ralph task-file dir moves whole.
+    const fromDir = join(source, "ralph");
+    const toDir = join(sessionDir, "ralph");
+    if (!existsSync(toDir) && existsSync(fromDir)) {
+      try {
+        renameSync(fromDir, toDir);
+        moved.push(fromDir);
+      } catch {
+        // Same: best-effort.
+      }
+    }
+  }
+  return moved;
+}
+
+// ── sibling scans ────────────────────────────────────────────────────────────
+
+export interface SiblingGraphOwner {
+  readonly sessionId: string;
+  readonly kind: "graph" | "swarm";
+  readonly label: string;
+  /** Set when the state declares one (best-effort; the session file's name). */
+  readonly sessionName?: string;
+  /** The owner's pid when stamped (running vs paused in the warning). */
+  readonly pid?: number;
+  readonly updatedAt: string;
+}
+
+interface OwnerLike {
+  active?: { kind?: string; label?: string; sessionId?: string; pid?: number };
+  parked?: { kind?: string; label?: string; sessionId?: string; pid?: number };
+  updatedAt?: string;
+}
+
+function readOwnerState(path: string): OwnerLike | undefined {
+  if (!existsSync(path)) return undefined;
+  try {
+    const parsed = JSON.parse(readJsonFile(path)) as OwnerLike;
+    return parsed && typeof parsed === "object" ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Shim so this module needs no core import for one read. */
+function readJsonFile(path: string): string {
+  return readFileSync(path, "utf8");
+}
+
+/**
+ * Sibling sessions holding an active/parked graph|swarm owner that is NOT
+ * this session's. `labelsById` maps session ids to names (best-effort).
+ */
+export function scanSiblingGraphOwners(
+  sessionsDir: string,
+  ownSessionId: string,
+  ...legacyDirs: (string | undefined)[]
+): SiblingGraphOwner[] {
+  const out: SiblingGraphOwner[] = [];
+  const push = (sessionId: string, state: OwnerLike | undefined, sessionName?: string, ownDir = true): void => {
+    for (const slot of ["active", "parked"] as const) {
+      const owner = state?.[slot];
+      if (!owner || (owner.kind !== "graph" && owner.kind !== "swarm")) continue;
+      // A sibling dir whose owner belongs to yet another session is skipped;
+      // legacy owners keep their real session id (the note needs it).
+      if (ownDir && owner.sessionId && owner.sessionId !== sessionId) continue;
+      out.push({
+        sessionId,
+        kind: owner.kind === "swarm" ? "swarm" : "graph",
+        label: owner.label ?? "",
+        ...(sessionName !== undefined ? { sessionName } : {}),
+        ...(owner.pid !== undefined ? { pid: owner.pid } : {}),
+        updatedAt: state?.updatedAt ?? "",
+      });
+      break;
+    }
+  };
+  try {
+    for (const entry of readdirSync(sessionsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name === ownSessionId) continue;
+      const state = readOwnerState(join(sessionsDir, entry.name, "state.json"));
+      // An owner stamped with OUR session id lives in our dir, not here.
+      if (state?.active?.sessionId === ownSessionId || state?.parked?.sessionId === ownSessionId) continue;
+      push(entry.name, state);
+    }
+  } catch {
+    // No sessions dir yet: fall through to the legacy scan.
+  }
+  // Leftover legacy state (pre-split workspace-level AND the older in-repo
+  // dir): warn the same way — the user should /resume the owning session.
+  for (const legacyDir of legacyDirs) {
+    if (!legacyDir) continue;
+    const state = readOwnerState(join(legacyDir, "state.json"));
+    if (state && state.active?.sessionId !== ownSessionId && state.parked?.sessionId !== ownSessionId) {
+      push("(legacy)", state, undefined, false);
+    }
+  }
+  return out.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1));
+}
+
+/** `process.kill(pid, 0)` — the stamped owner process is alive. */
+export function pidAlive(pid: number | undefined): boolean {
+  if (pid === undefined || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The one-line ui.notify note for a sibling graph owner (most recent wins). */
+export function graphOwnerNote(owner: SiblingGraphOwner | undefined): string | undefined {
+  if (!owner) return undefined;
+  const name = owner.sessionName ?? (owner.sessionId !== "(workspace)" ? owner.sessionId.slice(0, 12) : "another session");
+  if (pidAlive(owner.pid)) {
+    return `Agent ${owner.kind} "${owner.label}" is running in another session (${name}) — /resume it to follow it.`;
+  }
+  return `Agent ${owner.kind} "${owner.label}" is paused in another session (${name}) — /resume it to continue.`;
+}
+
+// ── history aggregate + read-only sibling results ────────────────────────────
+
+/** A graph file: `{ v, history: [...], current?: graph }`. */
+export interface GraphFile {
+  history: Array<Record<string, unknown> & { graphId?: string; createdAt?: number }>;
+  current?: Record<string, unknown> & { graphId?: string; createdAt?: number };
+}
+
+function readGraphFile(path: string): GraphFile | undefined {
+  if (!existsSync(path)) return undefined;
+  try {
+    const parsed = JSON.parse(readJsonFile(path)) as GraphFile;
+    if (!parsed || !Array.isArray(parsed.history)) return undefined;
+    return parsed;
+  } catch {
+    return undefined;
+  }
+}
+
+export function graphUpdatedAt(graph: Record<string, unknown>): number {
+  const at = graph.updatedAt ?? graph.createdAt;
+  return typeof at === "number" ? at : 0;
+}
+
+function isClosed(graph: Record<string, unknown>): boolean {
+  return !!(graph.finish || graph.abandoned);
+}
+
+/**
+ * Earlier graphs across the project: the caller's own list plus siblings'
+ * finished graphs (their `history` and a closed `current` — never another
+ * session's OPEN graph). Deduped by graphId, newest first.
+ */
+export function aggregateGraphHistory(
+  own: Array<Record<string, unknown> & { graphId?: string }>,
+  sessionsDir: string,
+  ownSessionId: string,
+): Array<Record<string, unknown> & { graphId?: string }> {
+  const byId = new Map<string, Record<string, unknown>>();
+  for (const graph of own) {
+    const id = graph.graphId;
+    if (typeof id === "string") byId.set(id, graph);
+  }
+  try {
+    for (const entry of readdirSync(sessionsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name === ownSessionId) continue;
+      const file = readGraphFile(join(sessionsDir, entry.name, "graph.json"));
+      if (!file) continue;
+      for (const graph of file.history) {
+        if (typeof graph.graphId === "string" && !byId.has(graph.graphId)) byId.set(graph.graphId, graph);
+      }
+      if (file.current && isClosed(file.current) && typeof file.current.graphId === "string" && !byId.has(file.current.graphId)) {
+        byId.set(file.current.graphId, file.current);
+      }
+    }
+  } catch {
+    // No sessions dir: only the engine's own history.
+  }
+  return [...byId.values()].sort((a, b) => graphUpdatedAt(b) - graphUpdatedAt(a));
+}
+
+/**
+ * Find a work item (by work id) inside a specific sibling graph (history or
+ * closed current) — read-only, for the Progress sheet's Full result.
+ */
+export function findSiblingWork(
+  sessionsDir: string,
+  ownSessionId: string,
+  graphId: string,
+  workId: string,
+): { work: Record<string, unknown>; graph: Record<string, unknown> } | undefined {
+  try {
+    for (const entry of readdirSync(sessionsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name === ownSessionId) continue;
+      const file = readGraphFile(join(sessionsDir, entry.name, "graph.json"));
+      if (!file) continue;
+      const candidates = [...file.history, ...(file.current && isClosed(file.current) ? [file.current] : [])];
+      const graph = candidates.find((g) => g.graphId === graphId);
+      if (!graph) continue;
+      const work = (graph["work"] as Array<Record<string, unknown>> | undefined)?.find((w) => w.workId === workId);
+      if (work) return { work, graph };
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+// ── housekeeping ─────────────────────────────────────────────────────────────
+
+const PRUNE_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+
+/**
+ * Remove sibling session dirs with no active/parked owner, no open graph and
+ * mtime older than 30 days. Best-effort, never throws.
+ */
+export function pruneSiblingSessionDirs(sessionsDir: string, ownSessionId: string, now: number): string[] {
+  const pruned: string[] = [];
+  try {
+    for (const entry of readdirSync(sessionsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name === ownSessionId) continue;
+      const dir = join(sessionsDir, entry.name);
+      try {
+        if (now - statSync(dir).mtimeMs <= PRUNE_AGE_MS) continue;
+        const state = readOwnerState(join(dir, "state.json"));
+        if (state?.active || state?.parked) continue;
+        const file = readGraphFile(join(dir, "graph.json"));
+        if (file?.current && !isClosed(file.current)) continue;
+        rmSync(dir, { recursive: true, force: true });
+        pruned.push(entry.name);
+      } catch {
+        // One bad dir never blocks the rest.
+      }
+    }
+  } catch {
+    // No sessions dir: nothing to prune.
+  }
+  return pruned;
+}
+
+/** The most recent mtime across a dir's own entries (best-effort). */
+export function dirMtime(dir: string): number {
+  try {
+    return statSync(dir).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+/** Whether a session dir has any long-horizon state yet. */
+export function sessionHasState(sessionDir: string): boolean {
+  return existsSync(join(sessionDir, "state.json")) || existsSync(join(sessionDir, "goal.json")) || existsSync(join(sessionDir, "graph.json"));
+}
+
+export { existsSync };

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

@@ -35,6 +35,7 @@ export const GRAPH_ORCHESTRATION_PROMPT = `<orchestration_mode>
 Graph Mode is active for this session. You are the main-agent supervisor beside the data path.
 - Use update_agent_graph to schedule bounded work onto child subagents when a graph materially improves the task. The host runs the work; do not call run_subagent for graph work.
 - Each add_work item needs a self-contained instruction (the child does not see this conversation). Give items a short work_id so later work can name them.
+- Each item's profile is your choice: pick per item (a read-only investigation uses subagent_explore; write-capable work uses subagent_general or a custom profile). view_agent_graph lists the profiles available right now; a profile you name that does not exist is refused.
 - Dependencies are input_ids: work ids (or result ids r-<work_id>) of this graph whose committed results the item consumes. Work waits until its inputs complete; the host attaches bounded upstream handoffs, so do not restate upstream conclusions in the instruction. You may declare the whole DAG in one update.
 - Use view_agent_graph to observe work status, operators, waits, failures and committed result ids.
 - After scheduling, call yield_agent_graph instead of polling, sleeping, or writing a waiting message. Yield ends only the current supervisor turn; the host wakes you at the next durable checkpoint (failure, nothing runnable, or everything settled) and the graph stays open.
@@ -55,7 +56,7 @@ Swarm Mode is active for this session. Treat the durable asynchronous agent grap
 - Perform only the lightweight exploration needed to establish boundaries before dispatch.
 - Make every item bounded and self-contained with an explicit scope, expected output, and constraints.
 - Avoid overlapping writes. Prefer read-only investigation (profile subagent_explore) unless isolated workspaces are available.
-- Schedule all independent items together with one update_agent_graph add_work (pick each item's profile). The host runs them; do not call run_subagent for swarm items.
+- Schedule all independent items together with one update_agent_graph add_work (pick each item's profile — view_agent_graph lists the profiles available right now; a read-only investigation uses subagent_explore, write-capable work uses subagent_general or a custom profile). The host runs them; do not call run_subagent for swarm items.
 - After scheduling, call yield_agent_graph. Do not poll, sleep, watch child logs, or wait synchronously; the host will wake you only when work needs attention or the whole swarm is settled.
 - On wake, call agent_swarm_status for compact statuses only. Read agent_output only for completed final results or narrow failed-item diagnosis.
 - Replace failed work with update_agent_graph using replaces=<failed work id> so the failed item no longer keeps the swarm in needs_attention. When all useful work is settled, finish the graph (operation=finish, result_ids, reason), deduplicate, verify, and semantically synthesize the results.
@@ -86,7 +87,7 @@ export interface GraphToolDeps {
 }
 
 /** Compact, model-facing view of one graph. */
-export function graphView(engine: GraphEngine, graph: GraphState, options: { history?: boolean } = {}): Record<string, unknown> {
+export function graphView(engine: GraphEngine, graph: GraphState, options: { history?: boolean; profiles?: readonly string[] } = {}): Record<string, unknown> {
   const status = (work: GraphWork) => engine.viewStatus(graph, work);
   const live = graph.work.filter((work) => work.status === "queued" || work.status === "running");
   const terminal = graph.work.filter((work) => work.status !== "queued" && work.status !== "running");
@@ -98,6 +99,9 @@ export function graphView(engine: GraphEngine, graph: GraphState, options: { his
     revision: graph.revision,
     state: graph.finish ? "finished" : graph.abandoned ? "stopped" : "open",
     counts: countStatuses(graph, status),
+    ...(options.profiles !== undefined && options.profiles.length > 0
+      ? { available_profiles: [...options.profiles] }
+      : {}),
     work: shown.map((work) => ({
       work_id: work.workId,
       status: status(work),
@@ -161,7 +165,7 @@ export function swarmStatus(engine: GraphEngine, graph: GraphState): Record<stri
 const workSchema = Type.Object({
   work_id: Type.Optional(Type.String({ description: "Short stable id for this work (e.g. scan-api). Later work names it in input_ids; its result id is r-<work_id>. Auto-assigned when omitted." })),
   instruction: Type.String({ description: "Bounded, self-contained instruction: scope, expected output, constraints. The child does not see this conversation." }),
-  profile: Type.Optional(Type.String({ description: `Subagent profile for new work (default ${DEFAULT_PROFILE}; subagent_explore for read-only investigation).` })),
+  profile: Type.Optional(Type.String({ description: `Subagent profile for this work (default ${DEFAULT_PROFILE}). Pick per work item: subagent_explore for read-only investigation, subagent_general for write-capable work on your model, or any custom profile listed in the Subagents section of your prompt. view_agent_graph reports the profiles available right now.` })),
   operator_id: Type.Optional(Type.String({ description: "Follow-up work on an EXISTING operator (from view_agent_graph): resumes that child's session. Omit for new work." })),
   input_ids: Type.Optional(Type.Array(Type.String(), { description: `Work ids or result ids (r-<work_id>) of THIS graph whose committed results this work consumes (its dependencies). Max ${MAX_INPUT_IDS}.` })),
   selected_result_inputs: Type.Optional(
@@ -270,11 +274,11 @@ export function registerGraphTools(pi: ExtensionAPI, deps: GraphToolDeps): void
       const graph = p.graph_id ? engine.graph(p.graph_id) : engine.current();
       if (!graph) {
         if (p.history && engine.history().length > 0) {
-          return textResult(JSON.stringify({ current: null, history: engine.history().slice(0, 10).map((past) => ({ graph_id: past.graphId, task: past.task, state: past.finish ? "finished" : "stopped", selected_result_ids: past.finish?.resultIds ?? [] })) }, null, 2));
+          return textResult(JSON.stringify({ current: null, profiles: deps.profiles(), history: engine.history().slice(0, 10).map((past) => ({ graph_id: past.graphId, task: past.task, state: past.finish ? "finished" : "stopped", selected_result_ids: past.finish?.resultIds ?? [] })) }, null, 2));
         }
-        return textResult(p.graph_id ? `No graph ${p.graph_id}.` : "No agent graph yet — schedule work with update_agent_graph operation=add_work.");
+        return textResult(p.graph_id ? `No graph ${p.graph_id}. Available profiles: ${deps.profiles().join(", ") || "none"}.` : `No agent graph yet — schedule work with update_agent_graph operation=add_work. Available profiles: ${deps.profiles().join(", ") || "none"}.`);
       }
-      return textResult(JSON.stringify(graphView(engine, graph, { history: p.history === true }), null, 2));
+      return textResult(JSON.stringify(graphView(engine, graph, { history: p.history === true, profiles: deps.profiles() }), null, 2));
     },
   });
 

package/packages/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/mcp",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "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"
+    "@pi-unipi/core": "3.0.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",

package/packages/memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/memory",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Persistent cross-session memory on MemPalace (auto-installed): daemon-routed writes, shared palace with other agents, for Pi coding agent",
   "type": "module",
   "main": "index.ts",
@@ -44,8 +44,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@pi-unipi/core": "3.0.0",
-    "@pi-unipi/info-screen": "3.0.0",
+    "@pi-unipi/core": "3.0.1",
+    "@pi-unipi/info-screen": "3.0.1",
     "js-yaml": "^4.1.0"
   },
   "peerDependencies": {

package/packages/notify/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/notify",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Cross-platform notification extension for Pi — native OS, Gotify, and Telegram notifications for agent lifecycle events",
   "type": "module",
   "main": "index.ts",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0",
+    "@pi-unipi/core": "3.0.1",
     "node-notifier": "^10.0.1"
   },
   "peerDependencies": {

package/packages/skill-registry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/skill-registry",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Skill registry for pi — per-project skill on/off, a skill vault, and jev-judged skill exposure",
   "type": "module",
   "license": "MIT",
@@ -33,7 +33,7 @@
   },
   "main": "index.ts",
   "dependencies": {
-    "@pi-unipi/core": "3.0.0"
+    "@pi-unipi/core": "3.0.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.87.1",

package/packages/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/subagents",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Subagents for UniPi — Devin-model independent child agents",
   "type": "module",
   "main": "src/index.ts",
@@ -9,8 +9,8 @@
     "test": "npx tsx --test src/__tests__/*.test.ts"
   },
   "dependencies": {
-    "@pi-unipi/core": "3.0.0",
-    "@pi-unipi/utility": "3.0.0",
+    "@pi-unipi/core": "3.0.1",
+    "@pi-unipi/utility": "3.0.1",
     "@earendil-works/pi-agent-core": "^0.87.1",
     "acorn": "8.18.0"
   },

package/packages/subagents/src/index.ts

@@ -5,8 +5,10 @@
  * reader registration for the shared core `read_subagent` tool.
  * Profiles: built-ins `subagent_explore` / `subagent_general` plus custom
  * markdown agents from ~/.unipi/config/agents and <workspace>/.unipi/config/agents.
+ * The agent files are re-read at SPAWN time, so a profile created mid-turn
+ * works immediately (no reload, no next prompt).
  * Config `subagents`: enabled, defaultModel, defaultThinking, maxConcurrent —
- * re-read every turn, so settings and agent files apply without a restart.
+ * re-read every turn, so settings apply without a restart.
  *
  * TUI (Devin parity): spawn card with a live tail, `Subagent "…" completed`
  * lines, the Subagents tab of the shared work tray (core/src/work/tray.ts —
@@ -240,6 +242,24 @@ export default function subagents(pi: ExtensionAPI, deps?: { manager?: SubagentM
     return loaded.warnings;
   }
 
+  /**
+   * The profiles as of NOW, re-read from disk.
+   *
+   * The turn-start snapshot goes stale the moment an agent file is created or
+   * edited: `before_agent_start` fires per PROMPT, so a profile written
+   * mid-turn stays invisible until the next user message — and `/reload` (or
+   * any new prompt) is what people reach for. Re-reading on every spawn costs
+   * two readdirs, while a child pi costs a whole process: read every time.
+   */
+  function currentProfiles(cwd: string): AgentProfile[] {
+    try {
+      profiles = loadProfiles(cwd).profiles;
+    } catch {
+      /* keep the last known list */
+    }
+    return profiles;
+  }
+
   /** reload + tool sync + warnings (runtime only — not during loading). */
   function refresh(cwd: string, ctx?: ExtensionContext): void {
     // Warnings surface once per distinct message per process.
@@ -483,7 +503,9 @@ export default function subagents(pi: ExtensionAPI, deps?: { manager?: SubagentM
     const cwd = ctx.cwd ?? process.cwd();
     const resumeId = params.resume?.trim() || undefined;
     const profileName = resumeId !== undefined ? (manager.record(resumeId)?.profile ?? params.profile) : params.profile;
-    const profile = profiles.find((p) => p.id === profileName);
+    // Re-read: a profile created or edited earlier in this turn is not in the
+    // turn-start snapshot yet.
+    const profile = currentProfiles(cwd).find((p) => p.id === profileName);
     if (!profile) {
       return textResult(`Unknown profile "${params.profile}". Available: ${profiles.map((p) => p.id).join(", ")}`, { owner: "subagents", status: "failed", title: params.title }, true);
     }
@@ -644,15 +666,17 @@ export default function subagents(pi: ExtensionAPI, deps?: { manager?: SubagentM
   // UNI-280: the Agent Graph (long-horizon) runs its work through this port.
   // Background-only; the graph owns completion (no completion notice here).
   const graphPort: GraphRunPort = {
-    profiles: () => (enabled && canSpawn() ? profiles.map((p) => p.id) : []),
+    // Fresh list: the graph validates a work item's profile against this, and
+    // a profile created earlier in this turn must be accepted, not refused.
+    profiles: () => (enabled && canSpawn() ? currentProfiles(uiCtx?.cwd ?? process.cwd()).map((p) => p.id) : []),
     start: (request) => {
       const ctx = uiCtx;
       if (ctx === undefined) return { error: "subagents are not ready (no session)", retryable: true };
       if (!enabled || !canSpawn()) return { error: "subagents are disabled in this session" };
+      const cwd = ctx.cwd ?? process.cwd();
       const resumeProfile = request.resume !== undefined ? manager.record(request.resume)?.profile : undefined;
-      const profile = profiles.find((p) => p.id === (resumeProfile ?? request.profile));
+      const profile = currentProfiles(cwd).find((p) => p.id === (resumeProfile ?? request.profile));
       if (!profile) return { error: `unknown subagent profile "${request.profile}" (available: ${profiles.map((p) => p.id).join(", ")})` };
-      const cwd = ctx.cwd ?? process.cwd();
       const start = manager.start({
         title: request.title,
         task: request.task,