pi-jar 0.1.9 → 0.2.1

package/src/delegate.ts

@@ -171,15 +171,18 @@ export function delegateArgs(model: string | undefined, thinking: string | undef
     : session.source ? ["--fork", session.source, "--session-dir", session.sessionDir]
     : ["--session-dir", session.sessionDir];
   const extensions = extensionFlags(argv);
+  const tools = session?.tools ?? toolOverride ?? (!write ? READ_ONLY_TOOLS : undefined);
+  const ownExtension = fileURLToPath(new URL("../extensions/index.ts", import.meta.url));
+  // Default read-only children need only core file tools and pi-jar. Avoid importing every
+  // personal extension (and opening unused MCP/provider connections) for each scout.
+  // Explicit extension flags and optional inherited tools retain the parent's full setup.
+  const lean = !write && extensions.length === 0 && tools?.every(tool => (READ_ONLY_TOOLS as readonly string[]).includes(tool));
+  if (lean) extensions.push("--no-extensions", "--extension", ownExtension);
   // Worktree cwd/session forks (resumed ones too) do not inherit project extension discovery from the parent.
-  if (session?.source) {
-    const ownExtension = fileURLToPath(new URL("../extensions/index.ts", import.meta.url));
-    if (!extensions.includes(ownExtension)) extensions.push("--extension", ownExtension);
-  }
+  else if (session?.source && !extensions.includes(ownExtension)) extensions.push("--extension", ownExtension);
   const args = ["--mode", "rpc", ...sessionArgs, ...extensions];
   if (model) args.push("--model", model);
   if (thinking) args.push("--thinking", thinking);
-  const tools = session?.tools ?? toolOverride ?? (!write ? READ_ONLY_TOOLS : undefined);
   if (tools) args.push("--tools", tools.join(","));
   return args;
 }
@@ -846,12 +849,11 @@ export function startDelegate(run: DelegateRun, args: string[], prompt: string,
       // Hibernated: there is no process to stop, so the agent simply ends here.
       if (!proc) { finish("done"); return; }
       if (run.state === "working" && !proc.hibernating) {
-        const waiting = waitSettled();
         send({ type: "clear_queue" });
-        if (send({ type: "abort" })) {
-          if (!await settlesWithin(waiting, 3000) && !finished) hardStop();
-        } else hardStop();
+        if (!send({ type: "abort" })) hardStop();
       }
+      // EOF follows the queued abort in the same pipe. Pi can now dispose immediately;
+      // do not spend an abort grace and then another full process-exit grace serially.
       const stdin = proc.child.stdin;
       if (stdin && !stdin.writableEnded) stdin.end();
       const killer = setTimeout(() => { if (proc.child.exitCode === null) hardStop(); }, 3000);
@@ -1256,6 +1258,9 @@ const peekRecord = (record: SubagentRecord): string => {
 const settledRecord = (record: SubagentRecord): string =>
   peekRecord(record) + (record.run.output ? `\nlast: ${cleanBlock(record.run.output, 1200)}` : "");
 
+/** One queued moderator notification; several coalesce into a single pi-jar.subagent message. */
+interface SubagentEvent { record: SubagentRecord; kind: "turn" | "control"; label: string; content: string; detail: Record<string, unknown> }
+
 /**
  * Every active worktree agent may still end up needing recovery, so admission reserves a recovery slot for
  * it: unresolved recovery workspaces never exceed RECOVERY_LIMIT, and none is ever deleted to make room.
@@ -1334,29 +1339,58 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, regi
       (raw as { customType?: string }).customType !== "pi-jar.moderator-context" || (active && index === latest)) };
   });
 
-  /** Native RPC drives registry state; Pi's message bus delivers frozen completion events to the moderator. */
+  /** Native RPC drives registry state. Completion events wait in our own queue, never Pi's irrevocable
+   * follow-up queue: while the moderator runs they join the next turn boundary so its final answer already
+   * reflects them, instead of re-waking it after that answer. Only events arriving while idle wake a turn. */
   const eventBusAvailable = typeof pi.sendMessage === "function";
   const watched = new Map<string, SubagentRecord>();
-  const settledQueue = new Map<string, { record: SubagentRecord; content: string; turn: number }>();
+  const pendingEvents = new Map<string, SubagentEvent>();
   const deleteSettled = (key: string) => {
-    for (const [eventKey, event] of settledQueue) if (event.record.key === key) settledQueue.delete(eventKey);
+    for (const [id, event] of pendingEvents) if (event.kind === "turn" && event.record.key === key) pendingEvents.delete(id);
   };
-  let notifyTimer: NodeJS.Timeout | undefined;
-  const flushSettled = () => {
-    notifyTimer = undefined;
-    const records = [...settledQueue.values()].filter(({ record }) => registry.get(record.key) === record);
-    settledQueue.clear();
-    if (!records.length) return;
-    try {
-      pi.sendMessage?.({
-        customType: SUBAGENT_MESSAGE, display: true, details: {
-          keys: [...new Set(records.map(({ record }) => record.key))],
-          turns: records.map(({ record, turn }) => ({ key: record.key, turn }))
-        },
-        content: ["[PI-JAR SUBAGENT] A subagent turn ended. Review, then resume, ask or stop:", ...records.map(event => event.content)].join("\n\n")
-      }, { triggerTurn: true, deliverAs: "followUp" });
-    } catch (error) { console.error("pi-jar: could not deliver a subagent event", error); }
+  let moderatorActive = false;
+  let moderatorInterrupted = false;
+  let wakeTimer: NodeJS.Timeout | undefined;
+  const takeEvents = () => {
+    clearTimeout(wakeTimer);
+    wakeTimer = undefined;
+    const events = [...pendingEvents.values()].filter(({ record }) => registry.get(record.key) === record);
+    pendingEvents.clear();
+    if (!events.length) return;
+    const summary = cleanText(`Subagents · ${events.map(event => event.label).join(" · ")}`, 160);
+    return {
+      customType: SUBAGENT_MESSAGE, display: true, details: { summary, events: events.map(event => event.detail) },
+      content: [`[PI-JAR SUBAGENT] ${summary}`, ...events.map(event => event.content), "Review, then resume, ask or stop retained agents as needed."].join("\n\n")
+    };
+  };
+  const scheduleWake = () => {
+    if (moderatorActive || moderatorInterrupted || wakeTimer || !pendingEvents.size) return;
+    wakeTimer = setTimeout(() => {
+      wakeTimer = undefined;
+      if (moderatorActive || moderatorInterrupted) return;
+      const message = takeEvents();
+      if (!message) return;
+      try { pi.sendMessage?.(message, { triggerTurn: true }); }
+      catch (error) { console.error("pi-jar: could not deliver a subagent event", error); }
+    }, NOTIFY_COALESCE_MS);
+    wakeTimer.unref?.();
+  };
+  const queueEvent = (id: string, event: SubagentEvent) => { pendingEvents.set(id, event); scheduleWake(); };
+  const boundary = (event: { outcome?: string; context?: { canContinue?: boolean } }) => {
+    if (event.outcome !== "completed" || event.context?.canContinue === false) return;
+    const message = takeEvents();
+    if (message) return { entries: [{ type: "custom_message" as const, ...message }], continue: true };
   };
+  pi.registerMessageRenderer?.<{ summary?: string }>(SUBAGENT_MESSAGE, (message, { expanded }, theme) => {
+    const text = typeof message.content === "string" ? message.content : "Subagents";
+    const summary = message.details?.summary ?? text.split("\n", 1)[0] ?? "Subagents";
+    return new Text(expanded ? text : theme.fg("accent", cleanText(summary, 160)) + theme.fg("dim", " · expand for report"), 0, 0);
+  });
+  pi.on?.("agent_start", () => { moderatorActive = true; moderatorInterrupted = false; clearTimeout(wakeTimer); wakeTimer = undefined; });
+  pi.on?.("turn_end", boundary);
+  pi.on?.("agent_before_settle", (event) => { moderatorInterrupted = event.outcome !== "completed"; return boundary(event); });
+  // An interrupted run keeps its events for the user's next prompt rather than auto-waking.
+  pi.on?.("agent_settled", () => { moderatorActive = false; scheduleWake(); });
   registry.subscribe(() => {
     if (!watched.size) return;
     for (const [key, record] of watched) {
@@ -1365,14 +1399,11 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, regi
       watched.delete(key);
       if (record.run.state !== "stopped") {
         // Freeze reports at the settled boundary. A fast resume must not overwrite a queued
-        // initial report, and multiple turns in the coalescing window must each be delivered.
-        settledQueue.set(`${key}:${record.run.resumes}`, { record, turn: record.run.resumes, content: settledRecord(record) });
+        // initial report, and multiple turns before delivery must each be delivered.
+        queueEvent(`${key}:${record.run.resumes}`, { record, kind: "turn", label: `${record.run.name} turn ended`,
+          content: settledRecord(record), detail: { key, turn: record.run.resumes } });
       }
     }
-    if (settledQueue.size && !notifyTimer) {
-      notifyTimer = setTimeout(flushSettled, NOTIFY_COALESCE_MS);
-      notifyTimer.unref?.();
-    }
   });
 
   const delegateTool: ToolDefinition<typeof Parameters> = {
@@ -1872,13 +1903,12 @@ export function registerDelegate(pi: ExtensionAPI, roles: ModelRoleManager, regi
   const deliverControl = (record: SubagentRecord, operation: { id: string; action: string }, result: { content: Array<{ text: string }>; details?: unknown; isError?: boolean }) => {
     // A session switch discards the old fleet. Never wake a new session with stale handoffs.
     if (registry.get(record.key) !== record) return;
-    try {
-      pi.sendMessage({
-        customType: SUBAGENT_MESSAGE, display: true,
-        details: { operationId: operation.id, action: operation.action, key: record.key, status: result.isError ? "failed" : "completed", report: result.details },
-        content: `[PI-JAR SUBAGENT] ${operation.action} ${operation.id} completed:\n${result.content.map(part => part.text).join("\n")}`
-      }, { triggerTurn: true, deliverAs: "followUp" });
-    } catch (error) { console.error("pi-jar: could not deliver a control event", error); }
+    const status = result.isError ? "failed" : "completed";
+    // The stop handoff supersedes any queued turn report for the same agent.
+    if (operation.action === "stop") deleteSettled(record.key);
+    queueEvent(operation.id, { record, kind: "control", label: `${operation.action} ${record.run.name} ${status}`,
+      content: `${operation.action} ${operation.id} ${status}:\n${result.content.map(part => part.text).join("\n")}`,
+      detail: { operationId: operation.id, action: operation.action, key: record.key, status, report: result.details } });
   };
 
   pi.registerTool({

package/src/model-roles.ts

@@ -139,7 +139,12 @@ function writeConfig(file: string, config: RoleConfig): void {
   }
 }
 
-export const projectRoleFile = (cwd: string) => join(cwd, ".pi", ROLE_FILE);
+function profileRolePath(directory: string, profileId = "default"): string {
+  if (!/^[a-z0-9-]+$/.test(profileId)) throw new Error("Invalid profile ID");
+  return profileId === "default" ? join(directory, ROLE_FILE) : join(directory, "pi-jar-profiles", `${profileId}-roles.json`);
+}
+export const profileRoleFile = (directory: string, profileId?: string) => profileRolePath(directory, profileId);
+export const projectRoleFile = (cwd: string, profileId?: string) => profileRolePath(join(cwd, ".pi"), profileId);
 
 export function describeRole(row: RoleRow): string {
   const target = row.error ? "⚠ " + row.error
@@ -152,6 +157,7 @@ export class ModelRoleManager {
   private global: RoleConfig = readConfig(join(getAgentDir(), ROLE_FILE));
   private project: RoleConfig = { version: 2, roles: {} };
   private cwd: string | undefined;
+  private profileId = "default";
   private active: string | undefined;
   private readonly pi: ExtensionAPI;
   /** True while pi-jar itself is switching models, so its own changes are not seen as manual. */
@@ -166,11 +172,21 @@ export class ModelRoleManager {
   }
 
   /** Reload global and project files; project assignments override global ones per role. */
-  load(cwd?: string): void {
-    this.global = readConfig(join(getAgentDir(), ROLE_FILE));
+  load(cwd?: string, profileRoles?: RoleConfig, profileId = "default"): void {
+    const profileFile = profileRoleFile(getAgentDir(), profileId);
+    this.global = profileRoles && !existsSync(profileFile) ? parseRoleConfig(profileRoles) : readConfig(profileFile);
     this.cwd = cwd;
-    this.project = cwd ? readConfig(projectRoleFile(cwd)) : { version: 2, roles: {} };
+    this.profileId = profileId;
+    this.project = cwd ? readConfig(projectRoleFile(cwd, profileId)) : { version: 2, roles: {} };
+  }
+  activeProfileId(): string { return this.profileId; }
+  /** Restore the label only, after a failed profile transaction restored model and effort. */
+  restoreActiveRole(role: string | undefined, ctx: ExtensionContext): void {
+    if (role !== undefined && !isRoleName(role)) throw new Error("Invalid role name");
+    this.active = role;
+    this.status(ctx);
   }
+  profileRoleConfig(): RoleConfig { return structuredClone(this.global); }
 
   private merged(): Record<string, string> { return { ...this.global.roles, ...this.project.roles }; }
   activeRole(): string | undefined { return this.active; }
@@ -288,7 +304,7 @@ export class ModelRoleManager {
     const epoch = this.manualEpoch;
     return async () => {
       // A model or effort the user picked during the workflow wins over the saved one.
-      if (this.manualEpoch !== epoch) { this.active = undefined; this.status(ctx); return; }
+      if (this.manualEpoch !== epoch) return;
       this.applying = true;
       try { if (previousModel) await this.pi.setModel(previousModel); this.pi.setThinkingLevel(previousThinking); }
       finally { this.applying = false; }
@@ -310,6 +326,9 @@ export class ModelRoleManager {
     return await this.activate(next, ctx) ? next : undefined;
   }
 
+  /** Invalidate temporary role restorations after a profile change. */
+  invalidateTemporaryRestores(): void { this.manualEpoch++; this.active = undefined; }
+
   /** Assign (or clear with undefined) a role in the chosen scope. */
   update(role: string, spec: string | undefined, scope: RoleScope = this.scopeOf(role) ?? "global"): void {
     if (!isRoleName(role)) throw new Error("Invalid role name: " + role);
@@ -320,7 +339,7 @@ export class ModelRoleManager {
     const roles = { ...target.roles };
     if (normalized) roles[role] = normalized; else delete roles[role];
     const next: RoleConfig = { ...target, version: 2, roles };
-    writeConfig(scope === "project" ? projectRoleFile(this.cwd!) : join(getAgentDir(), ROLE_FILE), next);
+    writeConfig(scope === "project" ? projectRoleFile(this.cwd!, this.profileId) : profileRoleFile(getAgentDir(), this.profileId), next);
     if (scope === "project") this.project = next; else this.global = next;
   }
 
@@ -346,11 +365,11 @@ export class ModelRoleManager {
     if (scope === "project" && !this.cwd) throw new Error("Project roles need a working directory");
     const target = scope === "project" ? this.project : this.global;
     const next: RoleConfig = { ...target, fallbacks: { ...target.fallbacks, [role]: [...new Set(normalized)] } };
-    writeConfig(scope === "project" ? projectRoleFile(this.cwd!) : join(getAgentDir(), ROLE_FILE), next);
+    writeConfig(scope === "project" ? projectRoleFile(this.cwd!, this.profileId) : profileRoleFile(getAgentDir(), this.profileId), next);
     if (scope === "project") this.project = next; else this.global = next;
   }
 
-  register(openUi?: (ctx: ExtensionContext) => Promise<void>, options: { activateDefault?: () => boolean } = {}): void {
+  register(openUi?: (ctx: ExtensionContext) => Promise<void>, options: { activateDefault?: () => boolean; beforeSessionStart?: (ctx: ExtensionContext) => { roles?: RoleConfig; profileId?: string } | undefined } = {}): void {
     const manual = (_event: unknown, ctx: ExtensionContext) => {
       if (this.applying) return;
       this.manualEpoch++;
@@ -359,7 +378,8 @@ export class ModelRoleManager {
     this.pi.on("model_select", manual);
     this.pi.on("thinking_level_select", manual);
     this.pi.on("session_start", async (_event, ctx) => {
-      this.load(ctx.cwd);
+      const profile = options.beforeSessionStart?.(ctx);
+      this.load(ctx.cwd, profile?.roles, profile?.profileId);
       this.active = undefined;
       // Delegated children already received their role model/effort via CLI arguments.
       if (options.activateDefault?.() !== false && this.resolveCandidates("default").length) await this.activate("default", ctx, true);

package/src/profile-ui.ts

@@ -0,0 +1,58 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { JarProfile, ProfileStore } from "./profiles.ts";
+
+export type ProfileAction = "create" | "switch";
+
+export interface ProfileUiOptions {
+  store: ProfileStore;
+  themes: readonly string[];
+  /** Copies the active profile's settings and roles into a new profile. */
+  create(name: string, theme: string): JarProfile;
+  /** Why the current session cannot switch profiles, or undefined when it can. */
+  switchBlocked(): string | undefined;
+  select(name: string): Promise<void>;
+  openRoles(): Promise<void>;
+}
+
+const CREATE = "+ Create profile…";
+const FOLLOW = "Follow Pi";
+
+/** Name and theme are the only creation questions; roles are configured afterwards in the roles UI. */
+export async function promptNewProfile(ctx: ExtensionContext, options: Pick<ProfileUiOptions, "store" | "themes" | "create">): Promise<JarProfile | undefined> {
+  const name = await ctx.ui.input("New profile name (1–32 characters)", "");
+  if (name === undefined) return undefined;
+  if (/[\u0000-\u001f\u007f-\u009f]/.test(name)) { ctx.ui.notify("Profile name cannot contain control characters", "warning"); return undefined; }
+  const normalized = name.trim().replace(/\s+/g, " ");
+  if (!normalized || normalized.length > 32 || /[\\/\0]/.test(normalized)) {
+    ctx.ui.notify("Profile name must be 1–32 characters and cannot contain slashes", "warning"); return undefined;
+  }
+  if (options.store.list().some((profile) => profile.name.toLocaleLowerCase() === normalized.toLocaleLowerCase())) {
+    ctx.ui.notify("A profile with that name already exists", "warning"); return undefined;
+  }
+  const selected = await ctx.ui.select("Choose a theme for " + normalized, [FOLLOW, ...options.themes.filter((item) => item !== "follow")]);
+  if (!selected) return undefined;
+  try { return options.create(normalized, selected === FOLLOW ? "follow" : selected); }
+  catch (error) { ctx.ui.notify("Could not create profile: " + (error as Error).message, "error"); return undefined; }
+}
+
+/** /profiles and the settings Profiles tab: create a profile or switch to one, nothing else. */
+export async function openProfiles(ctx: ExtensionContext, options: ProfileUiOptions, action?: ProfileAction): Promise<void> {
+  if (!ctx.hasUI || ctx.mode !== "tui") return;
+  const active = options.store.activeName;
+  if (action !== "create") {
+    const labels = new Map(options.store.list().map((profile) => [profile.name === active ? `${profile.name} (active)` : profile.name, profile.name]));
+    const choice = await ctx.ui.select(action === "switch" ? "Switch profile" : "Profiles", action === "switch" ? [...labels.keys()] : [CREATE, ...labels.keys()]);
+    if (!choice) return;
+    if (choice !== CREATE) { await options.select(labels.get(choice)!); return; }
+  }
+  const profile = await promptNewProfile(ctx, options);
+  if (!profile) return;
+  if (options.switchBlocked()) {
+    ctx.ui.notify(`Created profile ${profile.name} with ${active}'s model roles. Switch to it in a fresh session with /profiles, then set its roles with /roles.`, "info");
+    return;
+  }
+  await options.select(profile.name);
+  if (options.store.activeName !== profile.name) return;
+  ctx.ui.notify(`Created profile ${profile.name}. Its model roles start as a copy of ${active}'s; set them now in Roles (later: /roles).`, "info");
+  await options.openRoles();
+}

package/src/profiles.ts

@@ -0,0 +1,148 @@
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { isRoleName, normalizeSpec, parseRoleConfig, type RoleConfig } from "./model-roles.ts";
+import { isMaxSubagents, defaultVisualSettings, loadVisualSettings, type JarVisualSettings } from "./settings.ts";
+import { ACCENT_NAMES } from "./accent.ts";
+import { FOOTER_FIELDS } from "./footer-settings.ts";
+import { ICON_SETS } from "./icons.ts";
+
+export interface JarProfile { id: string; name: string; theme: string; settings: JarVisualSettings; roles: RoleConfig }
+interface ProfileDocument { version: 1; active: string; profiles: JarProfile[] }
+export const PROFILE_FILE = "pi-jar-profiles.json";
+export const DEFAULT_PROFILE = "Default";
+export const PROFILE_ENTRY = "pi-jar.profile";
+export function conversationStarted(entries: readonly unknown[]): boolean {
+  return entries.some((entry) => isPlainObject(entry) && (entry.role === "user"
+    || (entry.type === "message" && isPlainObject(entry.message) && entry.message.role === "user")));
+}
+export function pinnedProfileId(entries: readonly unknown[]): string | undefined {
+  for (const entry of [...entries].reverse()) {
+    if (isPlainObject(entry) && entry.type === "custom" && entry.customType === PROFILE_ENTRY
+      && isPlainObject(entry.data) && entry.data.version === 1 && typeof entry.data.id === "string") return entry.data.id;
+  }
+  return undefined;
+}
+const safeName = (value: string) => value.trim().replace(/\s+/g, " ");
+const profileId = () => `profile-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+const isPlainObject = (value: unknown): value is Record<string, unknown> => !!value && typeof value === "object" && !Array.isArray(value);
+
+function validProfileName(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0 && value.length <= 32 && !/[\\/\0\u0001-\u001f\u007f-\u009f]/.test(value) && value.trim() === value;
+}
+function normalizeProfile(value: unknown): JarProfile | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const raw = value as Record<string, unknown>;
+  if (!validProfileName(raw.name) || typeof raw.theme !== "string" || !raw.theme || !isPlainObject(raw.settings)
+    || raw.settings.version !== 1 || !isPlainObject(raw.roles) || raw.roles.version !== 2 || !isPlainObject(raw.roles.roles)) return undefined;
+  const settings = raw.settings;
+  const footer = settings.footer;
+  if (!["accent", "animations", "ui", "composer", "mascot", "suggestions", "goalRounds", "maxSubagents", "advisor", "advisorGates", "icons", "footer"].every((key) => key in settings)
+    || !isPlainObject(settings.footer) || typeof settings.animations !== "boolean" || typeof settings.ui !== "boolean"
+    || typeof settings.composer !== "boolean" || typeof settings.mascot !== "boolean" || typeof settings.suggestions !== "boolean"
+    || typeof settings.advisor !== "boolean" || typeof settings.advisorGates !== "boolean"
+    || (settings.contextDiet !== undefined && typeof settings.contextDiet !== "boolean") || !Number.isInteger(settings.goalRounds)
+    || (settings.goalRounds as number) < 1 || (settings.goalRounds as number) > 50
+    || !isMaxSubagents(settings.maxSubagents) || typeof settings.accent !== "string"
+    || !(settings.accent === "follow" || settings.accent === "default" || ACCENT_NAMES.includes(settings.accent as never))
+    || !ICON_SETS.includes(settings.icons as never)
+    || !isPlainObject(footer) || !FOOTER_FIELDS.every((field) => typeof footer[field] === "boolean")) return undefined;
+  if (raw.name === DEFAULT_PROFILE && raw.id !== "default") return undefined;
+  if (raw.name !== DEFAULT_PROFILE && (typeof raw.id !== "string" || !/^profile-[a-z0-9-]{8,64}$/.test(raw.id))) return undefined;
+  for (const [role, spec] of Object.entries(raw.roles.roles)) if (!isRoleName(role) || typeof spec !== "string" || !normalizeSpec(spec)) return undefined;
+  return { id: raw.id as string, name: raw.name, theme: raw.theme, settings: { ...raw.settings, contextDiet: settings.contextDiet ?? false } as unknown as JarVisualSettings, roles: parseRoleConfig(raw.roles) };
+}
+function atomicSave(file: string, document: ProfileDocument): string {
+  mkdirSync(join(file, ".."), { recursive: true });
+  const temporary = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  const text = JSON.stringify(document, null, 2) + "\n";
+  try { writeFileSync(temporary, text, { flag: "wx" }); renameSync(temporary, file); }
+  catch (error) { try { unlinkSync(temporary); } catch {} throw error; }
+  return text;
+}
+
+export class ProfileStore {
+  private document: ProfileDocument;
+  private savedContents: string | undefined;
+  readonly directory: string;
+  constructor(directory: string, initialTheme = "pi-jar-dark", initialRoles: RoleConfig = { version: 2, roles: {} }) {
+    this.directory = directory;
+    const file = join(directory, PROFILE_FILE);
+    let loaded: ProfileDocument | undefined;
+    let missing = false;
+    try {
+      this.savedContents = readFileSync(file, "utf8");
+      const raw: unknown = JSON.parse(this.savedContents);
+      if (!isPlainObject(raw) || raw.version !== 1 || !Array.isArray(raw.profiles) || typeof raw.active !== "string") throw new Error("Unsupported or malformed pi-jar profiles file");
+      const profiles: JarProfile[] = [];
+      const names = new Set<string>(); const ids = new Set<string>();
+      for (const entry of raw.profiles) {
+        const profile = normalizeProfile(entry);
+        if (!profile) throw new Error("Malformed profile entry");
+        const name = profile.name.toLocaleLowerCase();
+        if (names.has(name) || ids.has(profile.id)) throw new Error("Duplicate profile name or id");
+        names.add(name); ids.add(profile.id); profiles.push(profile);
+      }
+      if (profiles.filter((profile) => profile.name === DEFAULT_PROFILE && profile.id === "default").length !== 1) throw new Error("Missing or invalid Default profile");
+      const active = profiles.find((profile) => profile.name === raw.active || profile.id === raw.active)?.name;
+      if (!active) throw new Error("Active profile does not exist");
+      loaded = { version: 1, active, profiles };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") missing = true;
+      else throw new Error(`Cannot load ${PROFILE_FILE}: ${(error as Error).message}`);
+    }
+    if (!loaded && missing) {
+      let legacy = defaultVisualSettings();
+      try { legacy = loadVisualSettings(directory); } catch { /* default settings */ }
+      loaded = { version: 1, active: DEFAULT_PROFILE, profiles: [{ id: "default", name: DEFAULT_PROFILE, theme: initialTheme, settings: legacy, roles: parseRoleConfig(initialRoles) }] };
+    }
+    this.document = loaded!;
+    if (missing) this.persist();
+  }
+  private persist(next = this.document): void {
+    const file = join(this.directory, PROFILE_FILE);
+    let current: string | undefined;
+    try { current = readFileSync(file, "utf8"); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
+    if (current !== this.savedContents) throw new Error("Profiles changed in another session or externally; reload before saving");
+    this.savedContents = atomicSave(file, next);
+  }
+  list(): JarProfile[] { return this.document.profiles.map((profile) => structuredClone(profile)); }
+  active(): JarProfile { return structuredClone(this.document.profiles.find((profile) => profile.name === this.document.active)!); }
+  get activeName(): string { return this.document.active; }
+  update(name: string, patch: Partial<Pick<JarProfile, "theme" | "settings">>): JarProfile {
+    const index = this.document.profiles.findIndex((profile) => profile.name === name);
+    if (index < 0) throw new Error("Unknown profile: " + name);
+    const profiles = [...this.document.profiles];
+    const profile = normalizeProfile(structuredClone({ ...profiles[index]!, ...patch }));
+    if (!profile) throw new Error("Invalid profile settings or theme");
+    profiles[index] = profile;
+    const next = { ...this.document, profiles };
+    this.persist(next);
+    this.document = next;
+    return structuredClone(profile);
+  }
+  add(name: string, theme: string, settings: JarVisualSettings, roles: RoleConfig = { version: 2, roles: {} }): JarProfile {
+    if (typeof name !== "string" || /[\u0000-\u001f\u007f-\u009f]/.test(name)) throw new Error("Profile name cannot contain control characters");
+    const normalized = safeName(name);
+    if (!validProfileName(normalized)) throw new Error("Profile name must be 1–32 characters and cannot contain slashes");
+    if (this.document.profiles.some((profile) => profile.name.toLocaleLowerCase() === normalized.toLocaleLowerCase())) throw new Error("A profile with that name already exists");
+    const id = profileId();
+    const profile = normalizeProfile({ id, name: normalized, theme, settings: structuredClone(settings), roles });
+    if (!profile) throw new Error("Invalid profile settings, theme, or roles");
+    const next = { ...this.document, profiles: [...this.document.profiles, profile] };
+    this.persist(next);
+    this.document = next;
+    return structuredClone(profile);
+  }
+  activate(name: string): JarProfile {
+    if (!this.document.profiles.some((profile) => profile.name === name)) throw new Error("Unknown profile: " + name);
+    const next = { ...this.document, active: name };
+    this.persist(next);
+    this.document = next;
+    return this.active();
+  }
+  cycle(): JarProfile {
+    const index = this.document.profiles.findIndex((profile) => profile.name === this.document.active);
+    return this.activate(this.document.profiles[(index + 1) % this.document.profiles.length]!.name);
+  }
+}

package/src/settings-ui.ts

@@ -3,6 +3,7 @@ import { Key, matchesKey, truncateToWidth, visibleWidth, type TuiMouseEvent } fr
 import { FOOTER_FIELDS, type FooterField } from "./footer-settings.ts";
 import { ICON_SETS } from "./icons.ts";
 import { GOAL_ROUND_CHOICES, MAX_SUBAGENT_CHOICES, type JarAccent, type JarVisualSettings } from "./settings.ts";
+import type { ProfileAction } from "./profile-ui.ts";
 
 const LABELS: Record<FooterField, string> = {
   model: "Model", effort: "Model effort", sessionName: "Session name", cwd: "Working directory",
@@ -10,8 +11,7 @@ const LABELS: Record<FooterField, string> = {
   extras: "Extension statuses", branch: "Git branch"
 };
 
-type Page = "appearance" | "footer" | "pi";
-const PAGES: Page[] = ["appearance", "footer", "pi"];
+type Page = "appearance" | "footer" | "pi" | "profiles";
 
 /** Pi-level preferences pi-jar can toggle (written to Pi's own settings). */
 export interface PiPreferences {
@@ -26,18 +26,22 @@ export async function openJarSettings(
   current: () => JarVisualSettings,
   update: (settings: JarVisualSettings) => void,
   availableAccents: readonly string[],
-  pi?: PiPreferences
+  pi?: PiPreferences,
+  profiles?: { activeName(): string; open(action: ProfileAction): Promise<void> }
 ): Promise<void> {
   if (!ctx.hasUI || ctx.mode !== "tui") return;
-  await ctx.ui.custom<void>((tui, theme, _keys, done) => {
-    let page: Page = "appearance";
+  const PAGES: Page[] = profiles ? ["appearance", "footer", "pi", "profiles"] : ["appearance", "footer", "pi"];
+  let lastPage: Page = "appearance";
+  while (true) {
+  const action = await ctx.ui.custom<ProfileAction | undefined>((tui, theme, _keys, done) => {
+    let page: Page = lastPage;
     let selected = 0;
     let width = 64;
     const accents: JarAccent[] = ["follow", ...availableAccents.filter((name): name is JarAccent =>
       name === "default" || ["gray", "pink", "teal", "azure", "violet", "amber"].includes(name))];
     let choosing: "goalRounds" | "maxSubagents" | undefined;
     const choices = () => choosing === "maxSubagents" ? MAX_SUBAGENT_CHOICES : GOAL_ROUND_CHOICES;
-    const fields = () => choosing ? choices().length : page === "footer" ? FOOTER_FIELDS.length : page === "pi" ? 6 : 7;
+    const fields = () => choosing ? choices().length : page === "footer" ? FOOTER_FIELDS.length : page === "pi" ? 7 : page === "profiles" ? 2 : 7;
     const finishChoice = () => { selected = choosing === "maxSubagents" ? 3 : 2; choosing = undefined; };
     const piError = (error: unknown) => ctx.ui.notify("Could not change Pi setting: " + (error as Error).message, "error");
     const explainPool = () => choosing === "maxSubagents" || (page === "pi" && !choosing && selected === 3);
@@ -50,6 +54,10 @@ export async function openJarSettings(
         if (choosing === "maxSubagents") update({ ...state, maxSubagents: MAX_SUBAGENT_CHOICES[index]! });
         else update({ ...state, goalRounds: GOAL_ROUND_CHOICES[index]! });
         finishChoice();
+      } else if (page === "profiles") {
+        lastPage = page;
+        done(index === 0 ? "switch" : "create");
+        return;
       } else if (page === "footer") {
         const field = FOOTER_FIELDS[index];
         if (field) update({ ...state, footer: { ...state.footer, [field]: !state.footer[field] } });
@@ -66,6 +74,7 @@ export async function openJarSettings(
         }
         else if (index === 4) update({ ...state, advisor: !state.advisor });
         else if (index === 5) update({ ...state, advisorGates: !state.advisorGates });
+        else if (index === 6) update({ ...state, contextDiet: !state.contextDiet });
       } else if (index === 0) {
         const at = Math.max(0, accents.indexOf(state.accent));
         update({ ...state, accent: accents[(at + 1) % accents.length]! });
@@ -90,7 +99,7 @@ export async function openJarSettings(
       invalidate() {},
       handleInput(data: string) {
         if (matchesKey(data, Key.escape) || data === "q") {
-          if (choosing) { finishChoice(); tui.requestRender(); } else done();
+          if (choosing) { finishChoice(); tui.requestRender(); } else done(undefined);
           return;
         }
         if (choosing && (matchesKey(data, Key.tab) || matchesKey(data, Key.right)
@@ -112,19 +121,20 @@ export async function openJarSettings(
           tui.requestRender(); return { handled: true };
         }
         if (event.type !== "click" || event.button !== "left") return;
-        if (event.y === 0 && event.x >= width - 4) { done(); return { handled: true }; }
+        if (event.y === 0 && event.x >= width - 4) { done(undefined); return { handled: true }; }
         if (event.y === 1) {
           choosing = undefined;
           if (event.x >= 2 && event.x < Math.min(width - 2, 19)) { page = "appearance"; selected = 0; }
           else if (event.x >= 19 && event.x < Math.min(width - 2, 32)) { page = "footer"; selected = 0; }
-          else if (event.x >= 32 && event.x < width - 2) { page = "pi"; selected = 0; }
+          else if (event.x >= 32 && event.x < Math.min(width - 2, 41)) { page = "pi"; selected = 0; }
+          else if (profiles && event.x >= 41 && event.x < width - 2) { page = "profiles"; selected = 0; }
           else return;
           tui.requestRender(); return { handled: true, focus: true };
         }
         if (event.y >= 5 && event.y < 5 + visibleCount() && event.x >= 2 && event.x < width - 2) {
           selected = firstVisible() + event.y - 5; apply(selected); return { handled: true, focus: true };
         }
-        if (event.y === 5 + visibleCount() && event.x >= 2 && event.x < width - 2) { done(); return { handled: true }; }
+        if (event.y === 5 + visibleCount() && event.x >= 2 && event.x < width - 2) { done(undefined); return { handled: true }; }
       },
       render(available: number): string[] {
         width = Math.max(8, available);
@@ -136,7 +146,8 @@ export async function openJarSettings(
           + "─".repeat(Math.max(0, width - 4 - visibleWidth(title))) + "×╮");
         const tabs = line(theme.fg(page === "appearance" ? "accent" : "muted", "[ Appearance ]")
           + "   " + theme.fg(page === "footer" ? "accent" : "muted", "[ Footer ]")
-          + "   " + theme.fg(page === "pi" ? "accent" : "muted", "[ Pi ]"));
+          + "   " + theme.fg(page === "pi" ? "accent" : "muted", "[ Pi ]")
+          + (profiles ? "   " + theme.fg(page === "profiles" ? "accent" : "muted", "[ Profiles ]") : ""));
         const prefs = pi?.get();
         const divider = theme.fg("dim", "├" + "─".repeat(Math.max(0, width - 2)) + "┤");
         const allRows = choosing
@@ -149,7 +160,11 @@ export async function openJarSettings(
             row(2, "Goal auto rounds", String(state.goalRounds), true),
             row(3, "Max subagents (retained live pool)", String(state.maxSubagents), true),
             row(4, "Advisor (jar_advisor, /advisor)", state.advisor ? "ON" : "OFF", state.advisor),
-            row(5, "Advisor gates (loops, repeated failures)", state.advisorGates ? "ON" : "OFF", state.advisorGates)
+            row(5, "Advisor gates (loops, repeated failures)", state.advisorGates ? "ON" : "OFF", state.advisorGates),
+          row(6, "Context diet (prior-turn reasoning)", state.contextDiet ? "ON" : "OFF", state.contextDiet)
+          ] : page === "profiles" ? [
+            row(0, "Switch profile…", profiles!.activeName(), true),
+            row(1, "Create profile…", "OPEN", true)
           ] : [
             row(0, "Accent", state.accent === "follow" ? "FOLLOW PI" : state.accent.toUpperCase(), true),
             row(1, "Motion", state.animations ? "ON" : "OFF", state.animations),
@@ -163,11 +178,12 @@ export async function openJarSettings(
         const rows = allRows.slice(start, start + pageSize());
         return [top, tabs, divider,
           line(theme.fg("accent", choosing === "maxSubagents" ? " MAX SUBAGENTS · RETAINED LIVE POOL"
-            : choosing === "goalRounds" ? " GOAL AUTO ROUNDS" : page === "footer" ? " FOOTER VISIBILITY" : page === "pi" ? " PI & WORKFLOWS" : " APPEARANCE & MOTION")),
+            : choosing === "goalRounds" ? " GOAL AUTO ROUNDS" : page === "footer" ? " FOOTER VISIBILITY" : page === "pi" ? " PI & WORKFLOWS" : page === "profiles" ? " PROFILES" : " APPEARANCE & MOTION")),
           line(theme.fg("dim", explainPool() ? " Live pool includes idle/paused subagents"
             : choosing ? " Select a value; Enter/click to save, Esc to cancel"
             : page === "footer" ? ` Footer fields ${start + 1}–${start + rows.length}/${fields()}`
-            : page === "pi" ? " Fullscreen mode enables clicks and copy-on-select" : " Accent cycles through loaded themes")),
+            : page === "pi" ? " Fullscreen mode enables clicks and copy-on-select"
+            : page === "profiles" ? " Switch only in a fresh, idle session; roles via /roles" : " Accent cycles through loaded themes")),
           ...rows,
           line(theme.fg("dim", choosing ? " ↑↓: choose · Enter/click: save · Esc: cancel"
             : " Tab: section · ↑↓: choose · Enter/click: change · Esc")),
@@ -176,4 +192,10 @@ export async function openJarSettings(
       }
     };
   });
+  if (!action || !profiles) return;
+  try { await profiles.open(action); }
+  catch (error) { ctx.ui.notify("Could not change profile: " + (error as Error).message, "error"); }
+  // A new profile hands off to the roles UI; reopening settings over it would bury that step.
+  if (action === "create") return;
+  }
 }