pi-feats 0.1.5 → 0.1.7

package/extensions/cli-resources.ts

@@ -1,11 +1,14 @@
 import { SessionManager, type ExtensionAPI, type SessionInfo } from "@earendil-works/pi-coding-agent";
-import { Box, render, Text } from "ink";
-import React from "react";
 import { existsSync } from "node:fs";
 import { readFile, readdir, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { spawn } from "node:child_process";
+import { DatabaseSync } from "node:sqlite";
 import { BUILTIN_TOOLS, activeBuiltinTools, updatedBuiltinTools } from "./lib/builtin-tools.ts";
+import { packageExtensions, type InstalledPackage } from "./lib/package-resources.ts";
+import { withoutTuiModeArgs } from "./lib/cli-tui-mode.ts";
+import { piCommand } from "./lib/pi-command.ts";
+import { PulseStore, type PulseExecutionSession } from "./pulse/store.ts";
 
 type ListKind = "tools" | "skills" | "extensions";
 type Row = [string, string, string];
@@ -63,61 +66,29 @@ const actionFromArgs = (args: string[]): ParsedAction | undefined => {
 const clean = (value: string) => value.replaceAll("\n", " ").replaceAll("\t", " ");
 const clip = (value: string, width: number) => value.length <= width ? value : `${value.slice(0, Math.max(0, width - 1))}…`;
 
-function ResourceTable({ title, headers, rows, highlightStatus = false }: { title: string; headers: Row; rows: Row[]; highlightStatus?: boolean }) {
-  const terminalWidth = Math.max(80, process.stdout.columns ?? 80);
-  const available = terminalWidth - 10;
-  const widths: [number, number, number] = [
-    Math.max(12, Math.floor(available * 0.23)),
-    Math.max(12, Math.floor(available * 0.18)),
-    0,
-  ];
+function ResourceTable({ title, headers, rows }: { title: string; headers: Row; rows: Row[]; highlightStatus?: boolean }): string {
+  const available = Math.max(80, process.stdout.columns ?? 80) - 10;
+  const widths: [number, number, number] = [Math.max(12, Math.floor(available * 0.23)), Math.max(12, Math.floor(available * 0.18)), 0];
   widths[2] = available - widths[0] - widths[1];
   const cell = (value: string, width: number) => clip(clean(value), width).padEnd(width);
   const line = `┼${"─".repeat(widths[0] + 2)}┼${"─".repeat(widths[1] + 2)}┼${"─".repeat(widths[2] + 2)}┼`;
-  const top = line.replaceAll("┼", "┬").replace(/^┬/, "┌").replace(/┬$/, "┐");
-  const bottom = line.replaceAll("┼", "┴").replace(/^┴/, "└").replace(/┴$/, "┘");
+  const top = line.replaceAll("┼", "┬").replace(/^┬/, "┌").replace(/┬$/, "┐"), bottom = line.replaceAll("┼", "┴").replace(/^┴/, "└").replace(/┴$/, "┘");
   const row = (values: Row) => `│ ${cell(values[0], widths[0])} │ ${cell(values[1], widths[1])} │ ${cell(values[2], widths[2])} │`;
-
-  const renderedRow = (values: Row, index: number) => {
-    const statusColor = values[1] === "enabled" ? "green" : "#f5c2d7";
-    return React.createElement(
-      Box,
-      { flexDirection: "row", key: `${values.join("\0")}-${index}` },
-      React.createElement(Text, { color: "gray" }, "│ "),
-      React.createElement(Text, { color: "white" }, cell(values[0], widths[0])),
-      React.createElement(Text, { color: "gray" }, " │ "),
-      React.createElement(Text, { color: highlightStatus ? statusColor : "white" }, cell(values[1], widths[1])),
-      React.createElement(Text, { color: "gray" }, " │ "),
-      React.createElement(Text, { color: "white" }, cell(values[2], widths[2])),
-      React.createElement(Text, { color: "gray" }, " │"),
-    );
-  };
-
-  return React.createElement(
-    Box,
-    { flexDirection: "column" },
-    React.createElement(Text, { color: "cyan", bold: true }, title),
-    React.createElement(Text, { color: "gray" }, top),
-    React.createElement(Text, { color: "cyan", bold: true }, row(headers)),
-    React.createElement(Text, { color: "gray" }, line),
-    ...rows.map(renderedRow),
-    React.createElement(Text, { color: "gray" }, bottom),
-  );
+  return [title, top, row(headers), line, ...rows.map(row), bottom].join("\n");
 }
 
 type SourceRow = [string, string, string, string];
-function SourceTable({ title, detailHeader, rows }: { title: string; detailHeader: string; rows: SourceRow[] }) {
+function SourceTable({ title, detailHeader, rows }: { title: string; detailHeader: string; rows: SourceRow[] }): string {
   const available = Math.max(80, process.stdout.columns ?? 80) - 13, widths: [number, number, number, number] = [Math.max(14, Math.floor(available * .20)), 10, Math.max(18, Math.floor(available * .27)), 0];
   widths[3] = available - widths[0] - widths[1] - widths[2];
   const cell = (value: string, width: number) => clip(clean(value), width).padEnd(width);
   const line = `┼${"─".repeat(widths[0] + 2)}┼${"─".repeat(widths[1] + 2)}┼${"─".repeat(widths[2] + 2)}┼${"─".repeat(widths[3] + 2)}┼`;
   const top = line.replaceAll("┼", "┬").replace(/^┬/, "┌").replace(/┬$/, "┐"), bottom = line.replaceAll("┼", "┴").replace(/^┴/, "└").replace(/┴$/, "┘");
   const row = (values: SourceRow) => `│ ${cell(values[0], widths[0])} │ ${cell(values[1], widths[1])} │ ${cell(values[2], widths[2])} │ ${cell(values[3], widths[3])} │`;
-  const renderedRow = (values: SourceRow, index: number) => React.createElement(Box, { flexDirection: "row", key: `${values.join("\0")}-${index}` }, React.createElement(Text, { color: "gray" }, "│ "), React.createElement(Text, { color: "white" }, cell(values[0], widths[0])), React.createElement(Text, { color: "gray" }, " │ "), React.createElement(Text, { color: values[1] === "enabled" ? "green" : "#f5c2d7" }, cell(values[1], widths[1])), React.createElement(Text, { color: "gray" }, " │ "), React.createElement(Text, { color: "white" }, cell(values[2], widths[2])), React.createElement(Text, { color: "gray" }, " │ "), React.createElement(Text, { color: "white" }, cell(values[3], widths[3])), React.createElement(Text, { color: "gray" }, " │"));
-  return React.createElement(Box, { flexDirection: "column" }, React.createElement(Text, { color: "cyan", bold: true }, title), React.createElement(Text, { color: "gray" }, top), React.createElement(Text, { color: "cyan", bold: true }, row(["NAME", "STATUS", "SOURCE", detailHeader])), React.createElement(Text, { color: "gray" }, line), ...rows.map(renderedRow), React.createElement(Text, { color: "gray" }, bottom));
+  return [title, top, row(["NAME", "STATUS", "SOURCE", detailHeader]), line, ...rows.map(row), bottom].join("\n");
 }
 
-function SessionTable({ sessions }: { sessions: SessionInfo[] }) {
+function SessionTable({ sessions }: { sessions: SessionInfo[] }): string {
   const terminalWidth = Math.max(80, process.stdout.columns ?? 80);
   const available = terminalWidth - 13;
   const widths = {
@@ -138,20 +109,17 @@ function SessionTable({ sessions }: { sessions: SessionInfo[] }) {
     hour12: false,
   }).format(date);
 
-  return React.createElement(
-    Box,
-    { flexDirection: "column" },
-    React.createElement(Text, { color: "cyan", bold: true }, "SESSIONS"),
-    React.createElement(Text, { color: "gray" }, top),
-    React.createElement(Text, { color: "cyan", bold: true }, row(["ID", "SESSION", "LAST ACTIVITY", "PATH"])),
-    React.createElement(Text, { color: "gray" }, line),
-    ...sessions.map((session) => React.createElement(
-      Text,
-      { color: "white", key: session.path },
-      row([session.id, session.name ?? session.firstMessage, formatActivity(session.modified), session.path]),
-    )),
-    React.createElement(Text, { color: "gray" }, bottom),
-  );
+  return ["SESSIONS", top, row(["ID", "SESSION", "LAST ACTIVITY", "PATH"]), line, ...sessions.map((session) => row([session.id, session.name ?? session.firstMessage, formatActivity(session.modified), session.path])), bottom].join("\n");
+}
+
+type PulseListedSession = SessionInfo & { source: "execution" | "injected-result"; pulse?: PulseExecutionSession };
+function isPulseOnlySession(session: SessionInfo, sessionDir: string | undefined): boolean { const entries = SessionManager.open(session.path, sessionDir, session.cwd).getBranch() as Array<{ type?: string }>; const relevant = entries.filter((entry) => entry.type !== "session_info"); return relevant.length > 0 && relevant.some((entry) => entry.type === "pulse") && relevant.every((entry) => entry.type === "pulse"); }
+function PulseSessionTable(sessions: PulseListedSession[]): string { if (!sessions.length) return "PULSE SESSIONS\nNo Pulse sessions found."; return `PULSE SESSIONS\nID  SOURCE  TYPE  PULSE  STATUS  LAST ACTIVITY\n${sessions.map((session) => `${session.id}  ${session.source}  ${session.pulse?.pulseType ?? "—"}  ${session.pulse?.pulseName ?? "Pulse result"}  ${session.pulse?.status ?? "—"}  ${session.modified.toISOString()}`).join("\n")}`; }
+
+function ApplicationSessionTable(root: string, profile: string): string {
+  const path = join(root, "applications.db"); if (!existsSync(path)) return "";
+  const db = new DatabaseSync(path, { readOnly: true });
+  try { const rows = db.prepare("SELECT s.application_slug,s.session_prefix,s.session_id,s.session_type,s.message_count,s.updated_at FROM application_session_state st JOIN application_sessions s ON s.session_id=st.current_session_id WHERE st.profile=? ORDER BY s.updated_at DESC").all(profile) as Array<Record<string, unknown>>; if (!rows.length) return ""; const lines = rows.map((row) => `${String(row.session_id)}  ${String(row.session_type)}  ${Number(row.message_count)} ${String(row.session_type) === "stateless" ? "requests" : "messages"}  ${String(row.application_slug)}/${String(row.session_prefix)}`); return `APPLICATION SESSIONS\nID  TYPE  COUNT  ROUTE\n${lines.join("\n")}`; } finally { db.close(); }
 }
 
 function requestedProfile(): string | undefined {
@@ -177,7 +145,7 @@ async function readSettings() {
 }
 
 const isExcluded = (resourcePath: string, exclusions: string[]): boolean =>
-  exclusions.includes(`!${resourcePath}`);
+  exclusions.includes(`-${resourcePath}`) || exclusions.includes(`!${resourcePath}`);
 
 async function findSkillFiles(path: string): Promise<string[]> {
   if (!existsSync(path)) return [];
@@ -221,28 +189,34 @@ export async function skillRows(paths: string[], sharedSkillRoot: string, profil
   return rows.sort((a, b) => a[0].localeCompare(b[0]) || a[2].localeCompare(b[2]));
 }
 
-async function extensionRows(paths: string[], exclusions: string[], enabledExtensions?: string[]): Promise<Row[]> {
+type ExtensionIdentity = { name: string; aliases: string[] };
+
+export async function extensionRows(paths: string[], exclusions: string[], enabledExtensions?: string[], identitiesByPath = new Map<string, ExtensionIdentity>()): Promise<Row[]> {
   const rows: Row[] = [];
-  const enabled = (name: string, path: string) => !enabledExtensions || enabledExtensions.includes("*") || enabledExtensions.includes(name) ? !isExcluded(path, exclusions) : false;
+  const enabled = (identity: ExtensionIdentity, path: string) => !enabledExtensions || enabledExtensions.includes("*") || identity.aliases.some((name) => enabledExtensions.includes(name)) ? !isExcluded(path, exclusions) : false;
   for (const path of paths) {
     if (!existsSync(path)) continue;
     if ([".ts", ".js"].includes(extname(path))) {
-      rows.push([basename(path, extname(path)), enabled(basename(path, extname(path)), path) ? "enabled" : "disabled", path]);
+      const identity = identitiesByPath.get(path) ?? { name: basename(path, extname(path)), aliases: [basename(path, extname(path))] };
+      rows.push([identity.name, enabled(identity, path) ? "enabled" : "disabled", path]);
       continue;
     }
     // A configured directory with index.ts/index.js is one extension. Its
     // sibling source/config files are implementation details, not extensions.
     if (existsSync(join(path, "index.ts")) || existsSync(join(path, "index.js"))) {
-      rows.push([basename(path), enabled(basename(path), path) ? "enabled" : "disabled", path]);
+      const identity = identitiesByPath.get(path) ?? { name: basename(path), aliases: [basename(path)] };
+      rows.push([identity.name, enabled(identity, path) ? "enabled" : "disabled", path]);
       continue;
     }
     for (const entry of await readdir(path, { withFileTypes: true })) {
       if (entry.isFile() && [".ts", ".js"].includes(extname(entry.name))) {
         const resourcePath = join(path, entry.name);
-        rows.push([basename(entry.name, extname(entry.name)), enabled(basename(entry.name, extname(entry.name)), resourcePath) ? "enabled" : "disabled", resourcePath]);
+        const identity = identitiesByPath.get(resourcePath) ?? { name: basename(entry.name, extname(entry.name)), aliases: [basename(entry.name, extname(entry.name))] };
+        rows.push([identity.name, enabled(identity, resourcePath) ? "enabled" : "disabled", resourcePath]);
       } else if (entry.isDirectory() && (existsSync(join(path, entry.name, "index.ts")) || existsSync(join(path, entry.name, "index.js")))) {
         const resourcePath = join(path, entry.name);
-        rows.push([entry.name, enabled(entry.name, resourcePath) ? "enabled" : "disabled", resourcePath]);
+        const identity = identitiesByPath.get(resourcePath) ?? { name: entry.name, aliases: [entry.name] };
+        rows.push([identity.name, enabled(identity, resourcePath) ? "enabled" : "disabled", resourcePath]);
       }
     }
   }
@@ -250,7 +224,7 @@ async function extensionRows(paths: string[], exclusions: string[], enabledExten
 }
 
 type PackageResourceKind = "extensions" | "skills";
-type ConfiguredPackage = { source: string; base: string; name: string; manifest?: { version?: string; description?: string; pi?: { extensions?: unknown; skills?: unknown } } };
+type ConfiguredPackage = InstalledPackage & { source: string; manifest?: InstalledPackage["manifest"] & { version?: string; description?: string } };
 
 function packageBase(source: string, resourceRoot: string): string | undefined {
   if (source.startsWith("npm:")) return join(resourceRoot, "npm", "node_modules", source.slice(4));
@@ -279,8 +253,8 @@ async function configuredPackages(resourceRoot: string, settings: Record<string,
   return packages;
 }
 
-async function configuredPackageResources(resourceRoot: string, settings: Record<string, unknown>, kind: PackageResourceKind): Promise<Array<{ path: string; packageName: string }>> {
-  const paths: Array<{ path: string; packageName: string }> = [];
+async function configuredPackageResources(resourceRoot: string, settings: Record<string, unknown>, kind: PackageResourceKind): Promise<Array<{ path: string; packageName: string; name?: string }>> {
+  const paths: Array<{ path: string; packageName: string; name?: string }> = [];
   for (const pkg of await configuredPackages(resourceRoot, settings)) {
     const entries = pkg.manifest?.pi?.[kind];
     for (const entry of Array.isArray(entries) ? entries : []) {
@@ -291,7 +265,14 @@ async function configuredPackageResources(resourceRoot: string, settings: Record
 }
 
 async function configuredPackageExtensions(resourceRoot: string, settings: Record<string, unknown>) {
-  return configuredPackageResources(resourceRoot, settings, "extensions");
+  return packageExtensions(await configuredPackages(resourceRoot, settings));
+}
+
+async function extensionIdentity(resourcePath: string, resourceRoot: string, settings: Record<string, unknown>): Promise<ExtensionIdentity> {
+  const packageExtension = (await configuredPackageExtensions(resourceRoot, settings)).find((entry) => entry.path === resourcePath);
+  if (packageExtension) return { name: packageExtension.name, aliases: packageExtension.aliases };
+  const name = basename(resourcePath, extname(resourcePath));
+  return { name, aliases: [name] };
 }
 
 async function packageToolSources(resourceRoot: string, settings: Record<string, unknown>, names: string[]): Promise<Map<string, string>> {
@@ -318,19 +299,41 @@ async function applyPackageAction(action: PackageAction) {
   console.log(`Package "${name}" ${action.action === "enable" ? "enabled" : "disabled"} in ${join(agentDir, "settings.json")}. Use /reload to apply.`);
 }
 
-async function renderAndClose(element: React.ReactElement) {
-  const app = render(element, { stdout: process.stdout, stdin: process.stdin, exitOnCtrlC: false, patchConsole: false });
-  await new Promise((resolveRender) => setTimeout(resolveRender, 25));
-  app.unmount();
+async function writeTable(table: string) {
+  await new Promise<void>((resolveWrite, reject) => process.stdout.write(`${table}\n`, (error) => error ? reject(error) : resolveWrite()));
 }
 
 function setExclusion(entries: string[], resourcePath: string, disable: boolean) {
-  const exclusion = `!${resourcePath}`;
-  if (disable) return entries.includes(exclusion) ? entries : [...entries, exclusion];
-  return entries.filter((entry) => entry !== exclusion);
+  // Pi applies exact exclusions (`-path`) to resources discovered through a
+  // package manifest. `!path` is a glob exclusion and is retained only as a
+  // legacy value when reading existing settings.
+  const exactExclusion = `-${resourcePath}`;
+  const legacyGlobExclusion = `!${resourcePath}`;
+  if (disable) return [...entries.filter((entry) => entry !== legacyGlobExclusion && entry !== exactExclusion), exactExclusion];
+  return entries.filter((entry) => entry !== exactExclusion && entry !== legacyGlobExclusion);
+}
+
+export function updatedExtensionSettings(settings: Record<string, unknown>, resourcePath: string, identity: ExtensionIdentity, enable: boolean): Record<string, unknown> {
+  const entries = Array.isArray(settings.extensions) ? settings.extensions.filter((entry): entry is string => typeof entry === "string") : [];
+  const extensions = setExclusion(entries, resourcePath, !enable);
+  const updated: Record<string, unknown> = { ...settings };
+  if (extensions.length) updated.extensions = extensions;
+  else delete updated.extensions;
+
+  const profile = settings.profile;
+  const enabledExtensions = profile && typeof profile === "object" && Array.isArray((profile as Record<string, unknown>).enabledExtensions)
+    ? (profile as Record<string, unknown>).enabledExtensions.filter((entry): entry is string => typeof entry === "string")
+    : undefined;
+  if (enabledExtensions && !enabledExtensions.includes("*")) {
+    const selected = new Set(enabledExtensions);
+    for (const alias of identity.aliases) selected.delete(alias);
+    if (enable) selected.add(identity.name);
+    updated.profile = { ...(profile as Record<string, unknown>), enabledExtensions: [...selected].sort() };
+  }
+  return updated;
 }
 
-async function findResource(kind: "extensions" | "skills", target: string, settings: Record<string, unknown>, agentDir: string, resourceRoot: string) {
+export async function findResource(kind: "extensions" | "skills", target: string, settings: Record<string, unknown>, agentDir: string, resourceRoot: string) {
   if (existsSync(target)) {
     if (kind === "skills" && (basename(target) === "SKILL.md" || existsSync(join(target, "SKILL.md")))) {
       return basename(target) === "SKILL.md" ? dirname(target) : target;
@@ -344,10 +347,9 @@ async function findResource(kind: "extensions" | "skills", target: string, setti
   const roots = [join(agentDir, kind), ...(kind === "skills" ? [join(resourceRoot, "skills")] : []), ...rawEntries.filter((entry) => !/^[!+\-]/.test(entry)), join(process.cwd(), ".pi", kind)];
   const name = target.replace(/^[!+\-]+/, "");
   if (kind === "extensions") {
-    for (const entry of await configuredPackageExtensions(resourceRoot, settings)) {
-      const extensionName = basename(entry.path, extname(entry.path));
-      if (extensionName === name) return entry.path;
-    }
+    const matches = (await configuredPackageExtensions(resourceRoot, settings)).filter((entry) => entry.aliases.includes(name));
+    if (matches.length === 1) return matches[0].path;
+    if (matches.length > 1) throw new Error(`Extension name \"${target}\" is ambiguous; use its path.`);
   } else {
     for (const entry of await configuredPackageResources(resourceRoot, settings, "skills")) {
       for (const skillFile of await findSkillFiles(entry.path)) {
@@ -451,6 +453,17 @@ async function applyAction(action: ParsedAction) {
   const resourcePath = await findResource(action.kind, action.target, settings, agentDir, resourceRoot);
   if (!resourcePath) throw new Error(`${action.kind.slice(0, -1)} \"${action.target}\" não encontrada.`);
   if (action.kind === "skills" && await applyProfileSkillAction(action, resourcePath, settings, agentDir, resourceRoot, settingsPath)) return;
+  if (action.kind === "extensions") {
+    const identity = await extensionIdentity(resourcePath, resourceRoot, settings);
+    const updatedSettings = updatedExtensionSettings(settings, resourcePath, identity, enable);
+    if (JSON.stringify(settings) === JSON.stringify(updatedSettings)) {
+      console.log(`Extension \"${action.target}\" is already ${enable ? "enabled" : "disabled"}.`);
+      return;
+    }
+    await writeFile(settingsPath, `${JSON.stringify(updatedSettings, null, 2)}\n`, "utf8");
+    console.log(`Extension \"${identity.name}\" ${enable ? "enabled" : "disabled"} in ${settingsPath}. Use /reload to apply.`);
+    return;
+  }
   const entries = Array.isArray(settings[action.kind])
     ? settings[action.kind].filter((entry): entry is string => typeof entry === "string")
     : [];
@@ -472,7 +485,8 @@ export default async function (pi: ExtensionAPI) {
     default: false,
   });
 
-  const args = process.argv.slice(2);
+  const rawArgs = process.argv.slice(2);
+  const args = withoutTuiModeArgs(rawArgs);
   // Remote commands must reach the profiles extension before this extension
   // creates its local --no-session helper process. The remote Pi will process
   // resource commands on its own host/runtime.
@@ -482,8 +496,11 @@ export default async function (pi: ExtensionAPI) {
   const packageRequested = packageRequestedFromArgs(args);
   const packageAction = packageActionFromArgs(args);
   const sessionRename = sessionRenameFromArgs(args);
-  const sessionRequested = args.some((arg) => arg === "--list-sessions" || arg === "--list-sessions=true")
-    || args.some((arg, index) => arg === "sessions" && args[index + 1] === "list");
+  const sessionListIndex = args.findIndex((arg, index) => arg === "sessions" && args[index + 1] === "list");
+  const sessionFilterCandidate = sessionListIndex >= 0 ? args[sessionListIndex + 2] : undefined;
+  const sessionFilter = sessionFilterCandidate?.startsWith("--") ? undefined : sessionFilterCandidate;
+  if (sessionFilter !== undefined && sessionFilter !== "pulses") throw new Error(`Unknown sessions list filter: ${sessionFilter}`);
+  const sessionRequested = args.some((arg) => arg === "--list-sessions" || arg === "--list-sessions=true") || sessionListIndex >= 0;
   if (!kind && !action && !packageRequested && !packageAction && !sessionRequested && !sessionRename) return;
 
   // Run CLI operations in an ephemeral child so they never create an empty session.
@@ -491,7 +508,8 @@ export default async function (pi: ExtensionAPI) {
     const profile = requestedProfile();
     const root = process.env.PI_PROFILE_ROOT ?? process.env.PI_CODING_AGENT_DIR ?? join(process.env.HOME ?? "", ".pi", "agent");
     const target = profile ? join(root, "profiles", profile) : process.env.PI_CODING_AGENT_DIR;
-    const child = spawn(process.execPath, [process.argv[1], "--no-session", ...args], {
+    const pi = piCommand();
+    const child = spawn(pi.command, [...pi.args, "--no-session", ...rawArgs], {
       stdio: "inherit",
       env: { ...process.env, PI_CLI_RESOURCES: "1", PI_CODING_AGENT_DIR: target, PI_PROFILE_ROOT: root, ...(profile ? { PI_ACTIVE_PROFILE: profile } : {}) },
     });
@@ -502,6 +520,18 @@ export default async function (pi: ExtensionAPI) {
     process.exit(code);
   }
 
+  if (sessionRequested) {
+    const sessionDir = process.env.PI_CODING_AGENT_SESSION_DIR;
+    const sessions = sessionDir ? await SessionManager.listAll(sessionDir) : await SessionManager.listAll();
+    const profile = process.env.PI_ACTIVE_PROFILE ?? requestedProfile() ?? "default", root = process.env.PI_PROFILE_ROOT ?? process.env.PI_CODING_AGENT_DIR ?? join(process.env.HOME ?? "", ".pi", "agent");
+    const pulseExecutions = new PulseStore(join(root, "pulse.db")).executionSessions(profile);
+    const pulseSessions: PulseListedSession[] = sessions.flatMap((session) => { const pulse = pulseExecutions.get(session.id); if (pulse) return [{ ...session, source: "execution", pulse }]; return isPulseOnlySession(session, sessionDir) ? [{ ...session, source: "injected-result" }] : []; });
+    const pulseSessionIds = new Set(pulseSessions.map((session) => session.id));
+    if (sessionFilter === "pulses") await writeTable(PulseSessionTable(pulseSessions));
+    else await writeTable([SessionTable({ sessions: sessions.filter((session) => !pulseSessionIds.has(session.id)) }), ApplicationSessionTable(root, profile)].filter(Boolean).join("\n\n"));
+    process.exit(0);
+  }
+
   if (sessionRename) {
     try {
       if (!sessionRename.name) throw new Error("Session name cannot be empty.");
@@ -541,13 +571,9 @@ export default async function (pi: ExtensionAPI) {
   }
 
   pi.on("session_start", async () => {
-    if (sessionRequested) {
-      const sessionDir = process.env.PI_CODING_AGENT_SESSION_DIR;
-      const sessions = sessionDir ? await SessionManager.listAll(sessionDir) : await SessionManager.listAll();
-      await renderAndClose(React.createElement(SessionTable, { sessions }));
-    } else if (packageRequested) {
+    if (packageRequested) {
       const { resourceRoot, runtimeSettings } = await readSettings();
-      await renderAndClose(React.createElement(ResourceTable, { title: "PACKAGES", headers: ["NAME", "STATUS", "VERSION / DESCRIPTION"], rows: await packageRows(resourceRoot, runtimeSettings), highlightStatus: true }));
+      await writeTable(ResourceTable({ title: "PACKAGES", headers: ["NAME", "STATUS", "VERSION / DESCRIPTION"], rows: await packageRows(resourceRoot, runtimeSettings), highlightStatus: true }));
     } else if (kind === "tools") {
       const active = new Set(pi.getActiveTools());
       const { resourceRoot, runtimeSettings } = await readSettings();
@@ -555,7 +581,7 @@ export default async function (pi: ExtensionAPI) {
       const rows: SourceRow[] = pi.getAllTools()
         .map((tool) => [tool.name, active.has(tool.name) ? "enabled" : "disabled", (BUILTIN_TOOLS as readonly string[]).includes(tool.name) ? "Built-in" : sources.has(tool.name) ? `npm: ${sources.get(tool.name)}` : "Extension", tool.description] as SourceRow)
         .sort((a, b) => a[0].localeCompare(b[0]));
-      await renderAndClose(React.createElement(SourceTable, { title: "TOOLS", detailHeader: "DESCRIPTION", rows }));
+      await writeTable(SourceTable({ title: "TOOLS", detailHeader: "DESCRIPTION", rows }));
     } else {
       const loaded = await readSettings();
       const resourceRoot = loaded.resourceRoot;
@@ -563,19 +589,24 @@ export default async function (pi: ExtensionAPI) {
       const settings = kind === "extensions" ? loaded.runtimeSettings : loaded.settings;
       const rawEntries = Array.isArray(settings[kind]) ? settings[kind].filter((value): value is string => typeof value === "string") : [];
       const configuredPaths = rawEntries.filter((value) => !/^[!+\-]/.test(value));
-      const exclusions = rawEntries.filter((value) => value.startsWith("!"));
+      const exclusions = rawEntries.filter((value) => value.startsWith("!") || value.startsWith("-"));
       const catalogRoot = join(resourceRoot, kind);
-      const packageResources = await configuredPackageResources(resourceRoot, loaded.runtimeSettings, kind === "extensions" ? "extensions" : "skills");
+      const packageResources = kind === "extensions"
+        ? await configuredPackageExtensions(resourceRoot, loaded.runtimeSettings)
+        : await configuredPackageResources(resourceRoot, loaded.runtimeSettings, "skills");
       const paths = kind === "skills"
         ? [...new Set([catalogRoot, ...configuredPaths, ...packageResources.map(({ path }) => path)])]
         : [...new Set([...(configuredPaths.length > 0 ? configuredPaths : [catalogRoot]), ...packageResources.map(({ path }) => path)])];
       const profileSkillRoot = kind === "skills" && loaded.agentDir !== resourceRoot ? join(loaded.agentDir, "skills") : undefined;
-      const rows: SourceRow[] = (kind === "skills" ? await skillRows(paths, catalogRoot, profileSkillRoot, settings, exclusions) : await extensionRows(paths, exclusions, (loaded.runtimeSettings.profile as { enabledExtensions?: string[] } | undefined)?.enabledExtensions)).map((row) => {
+      const extensionIdentities = new Map(packageResources.flatMap((resource) => "aliases" in resource && Array.isArray(resource.aliases)
+        ? [[resource.path, { name: resource.name, aliases: resource.aliases }] as const]
+        : []));
+      const rows: SourceRow[] = (kind === "skills" ? await skillRows(paths, catalogRoot, profileSkillRoot, settings, exclusions) : await extensionRows(paths, exclusions, (loaded.runtimeSettings.profile as { enabledExtensions?: string[] } | undefined)?.enabledExtensions, extensionIdentities)).map((row) => {
         const packageName = packageResources.find(({ path }) => row[2] === path || isWithin(row[2], path))?.packageName;
         const source = packageName ? `Package: ${packageName}` : (row[2].startsWith(join(resourceRoot, "skills")) ? "Shared" : row[2].includes("/profiles/") ? "Profile" : "Local");
         return [row[0], row[1], source, row[2]];
       });
-      await renderAndClose(React.createElement(SourceTable, { title: kind.toUpperCase(), detailHeader: "PATH", rows }));
+      await writeTable(SourceTable({ title: kind.toUpperCase(), detailHeader: "PATH", rows }));
     }
     // This command always runs in an ephemeral child process.
     process.exit(0);

package/extensions/cli-tui-mode.ts

@@ -0,0 +1,7 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { reexecCliWithRegularTui } from "./lib/cli-tui-mode.ts";
+
+/** Keep finite pi-feats CLI commands out of Pi's alternate-screen TUI. */
+export default async function (_pi: ExtensionAPI) {
+  await reexecCliWithRegularTui();
+}

package/extensions/context-memory/index.ts

@@ -10,7 +10,12 @@ const agentRoot = () => process.env.PI_PROFILE_ROOT ?? process.env.PI_CODING_AGE
 const profileDirectory = () => process.env.PI_CODING_AGENT_DIR ?? agentRoot();
 function executionContext() {
   const application = applicationExecutionContext.getStore();
-  return { application: application?.application ?? process.env.PI_APPLICATION_SLUG, identityKey: application?.identityKey ?? process.env.PI_APPLICATION_IDENTITY_KEY, profile: application?.profile ?? process.env.PI_ACTIVE_PROFILE ?? "default", sessionId: application?.sessionId ?? process.env.PI_APPLICATION_SESSION_ID };
+  const encodedDirectMemory = process.env.PI_APPLICATION_DIRECT_CONTEXT_MEMORY;
+  let directContextMemory = application?.directContextMemory;
+  if (directContextMemory === undefined && encodedDirectMemory) {
+    try { directContextMemory = Buffer.from(encodedDirectMemory, "base64url").toString("utf8"); } catch { /* validation happens during context resolution */ }
+  }
+  return { application: application?.application ?? process.env.PI_APPLICATION_SLUG, identityKey: application?.identityKey ?? process.env.PI_APPLICATION_IDENTITY_KEY, profile: application?.profile ?? process.env.PI_ACTIVE_PROFILE ?? "default", sessionId: application?.sessionId ?? process.env.PI_APPLICATION_SESSION_ID, directContextMemory };
 }
 
 export default function registerContextMemory(pi: ExtensionAPI): void {

package/extensions/guardrails/index.ts

@@ -5,6 +5,7 @@ import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
+import { withoutTuiModeArgs } from "../lib/cli-tui-mode.ts";
 
 type Stage = "input" | "pre_tool" | "post_tool" | "output";
 type Mode = "transform" | "evaluate" | "reflect";
@@ -97,7 +98,7 @@ export default function (pi: ExtensionAPI) {
   // `pi guardrails …` is implemented by profiles.ts before Pi opens a model
   // session. Do not register a slash command for that positional CLI form:
   // Pi would dispatch it as an interactive command and require credentials.
-  if (process.argv.slice(2)[0] === "guardrails") return;
+  if (withoutTuiModeArgs(process.argv.slice(2))[0] === "guardrails") return;
 
   let reflectionCount = 0;
 

package/extensions/lib/application-context.ts

@@ -16,6 +16,8 @@ export type ApplicationExecutionContext = {
   identityKey: string;
   profile: string;
   sessionId: string;
+  /** Non-persistent personal context supplied by an Application Direct Mode request. */
+  directContextMemory?: string;
   onContextMemoryExecution?: (event: ContextMemoryExecutionLog) => void;
 };
 

package/extensions/lib/cli-tui-mode.ts

@@ -0,0 +1,72 @@
+import { spawn } from "node:child_process";
+import { piCommand } from "./pi-command.ts";
+
+const profileManagementActions = new Set(["add", "create", "delete", "list", "open", "remove", "resume"]);
+const profileResourceCommands = new Set(["extensions", "packages", "sessions", "skills", "tools"]);
+const topLevelCliCommands = new Set(["api", "console", "guardrails", "pulse", "ssh", "tools", "skills", "extensions", "packages", "sessions"]);
+
+/** Remove the Pi TUI override before an extension dispatches positional CLI arguments. */
+export function withoutTuiModeArgs(raw: string[]): string[] {
+  const args: string[] = [];
+  for (let index = 0; index < raw.length; index += 1) {
+    const value = raw[index];
+    if (value === "--tui-mode") { index += 1; continue; }
+    if (value.startsWith("--tui-mode=")) continue;
+    args.push(value);
+  }
+  return args;
+}
+
+export function hasTuiModeArg(args: string[]): boolean {
+  return args.includes("--tui-mode");
+}
+
+/** Preserve an explicit user preference; otherwise make a finite CLI command render normally. */
+export function withRegularTuiMode(args: string[]): string[] {
+  return hasTuiModeArg(args) ? args : [...args, "--tui-mode", "regular"];
+}
+
+function profileCommandIsNonInteractive(args: string[]): boolean {
+  const action = args[1];
+  if (!action) return false;
+  if (profileManagementActions.has(action.toLowerCase())) return true;
+  return !profileManagementActions.has(action.toLowerCase()) && Boolean(args[2]) && (
+    profileResourceCommands.has(args[2]) || ["api", "console", "guardrails", "pulse", "ssh"].includes(args[2])
+  );
+}
+
+/**
+ * True only for pi-feats commands that produce a finite CLI result. Interactive
+ * Pi launches intentionally retain the selected profile's TUI preference.
+ */
+export function isPiFeatsNonInteractiveCli(raw: string[]): boolean {
+  const args = withoutTuiModeArgs(raw);
+  const command = args[0];
+  if (!command) return false;
+  if (topLevelCliCommands.has(command)) return true;
+  if (command === "profile") return profileCommandIsNonInteractive(args);
+  if (command === "remote") return ["add", "list", "delete"].includes(args[1] ?? "");
+
+  const remote = command.match(/^remote:[a-zA-Z][a-zA-Z0-9_-]{0,63}$/);
+  if (!remote) return false;
+  const nested = args.slice(1);
+  if (!nested.length || nested[0] === "bash") return false;
+  if (nested[0] === "profile") return profileCommandIsNonInteractive(nested);
+  return topLevelCliCommands.has(nested[0]);
+}
+
+/** Re-exec finite pi-feats CLI commands before Pi initializes its TUI. */
+export async function reexecCliWithRegularTui(): Promise<boolean> {
+  const args = process.argv.slice(2);
+  if (!isPiFeatsNonInteractiveCli(args) || hasTuiModeArg(args)) return false;
+  const pi = piCommand();
+  const child = spawn(pi.command, [...pi.args, ...withRegularTuiMode(args)], {
+    stdio: "inherit",
+    env: process.env,
+  });
+  const code = await new Promise<number>((resolveExit, reject) => {
+    child.once("error", reject);
+    child.once("exit", (exitCode) => resolveExit(exitCode ?? 1));
+  });
+  process.exit(code);
+}

package/extensions/lib/context-memory.ts

@@ -13,7 +13,7 @@ export type ContextMemoryConfig =
 export type ContextMemoryTarget = "operational" | "profile" | "user";
 export type ContextMemoryToolTarget = "operational" | "personal";
 export type ContextMemoryAction = "read" | "insert" | "update" | "remove" | "replace";
-export type MemoryExecutionContext = { application?: string; identityKey?: string; profile: string; sessionId?: string };
+export type MemoryExecutionContext = { application?: string; identityKey?: string; profile: string; sessionId?: string; directContextMemory?: string };
 export const CONTEXT_MEMORY_LIMITS = { operational: 2750, profile: 1375, user: 1375 } as const;
 const MAX_FILE_BYTES = 64 * 1024;
 const sensitive = /\b(password|passphrase|api[_ -]?key|secret|access[_ -]?token|refresh[_ -]?token|private[_ -]?key|cpf|credit[_ -]?card)\b/i;
@@ -116,6 +116,11 @@ async function handlerMemory(agentDir: string, profileDir: string, context: Memo
 export async function resolveContextMemory(agentDir: string, profileDir: string, context: MemoryExecutionContext): Promise<{ operational: string; personal: string; source?: string; handlerExecution?: ContextMemoryExecutionLog }> {
   const operational = await readMemory(memoryPath(agentDir, profileDir, "operational"));
   if (contextMemoryCharacters(operational) > CONTEXT_MEMORY_LIMITS.operational) throw new Error("OPERATIONAL.md exceeds 2750 characters.");
+  if (context.directContextMemory !== undefined) {
+    const personal = context.directContextMemory.trim();
+    if (contextMemoryCharacters(personal) > CONTEXT_MEMORY_LIMITS.user) throw new Error("Direct Context Memory exceeds 1375 characters.");
+    return { operational, personal, source: "direct" };
+  }
   const config = await profileMemoryConfig(profileDir);
   if (!config) return { operational, personal: "" };
   if (config.mode === "file" && config.target === "profile") { const personal = await readMemory(memoryPath(agentDir, profileDir, "profile")); if (contextMemoryCharacters(personal) > CONTEXT_MEMORY_LIMITS.profile) throw new Error("PROFILE.md exceeds 1375 characters."); return { operational, personal, source: "profile" }; }

package/extensions/lib/package-resources.ts

@@ -0,0 +1,58 @@
+import { basename, extname, join } from "node:path";
+
+export type PackageManifest = {
+  pi?: { extensions?: unknown; skills?: unknown };
+};
+
+export type InstalledPackage = {
+  base: string;
+  name: string;
+  manifest?: PackageManifest;
+};
+
+export type PackageExtension = {
+  name: string;
+  aliases: string[];
+  path: string;
+  packageName: string;
+};
+
+const extensionFileName = (entry: string) => basename(entry, extname(entry));
+
+/**
+ * Derive stable user-facing names for package extensions.
+ *
+ * A package whose only extension is an index entry uses the package name so
+ * users do not have to address a generic "index" extension. The technical
+ * entry name remains an alias for backwards compatibility.
+ */
+export function packageExtensions(packages: InstalledPackage[]): PackageExtension[] {
+  const candidates: Array<PackageExtension & { preferredName: string }> = [];
+  for (const pkg of packages) {
+    const entries = Array.isArray(pkg.manifest?.pi?.extensions)
+      ? pkg.manifest.pi.extensions.filter((entry): entry is string => typeof entry === "string")
+      : [];
+    const soleIndexEntry = entries.length === 1 && extensionFileName(entries[0]) === "index";
+    for (const entry of entries) {
+      const technicalName = extensionFileName(entry);
+      const preferredName = soleIndexEntry ? pkg.name : technicalName;
+      candidates.push({
+        name: preferredName,
+        preferredName,
+        aliases: [...new Set([preferredName, technicalName])],
+        path: join(pkg.base, entry),
+        packageName: pkg.name,
+      });
+    }
+  }
+
+  const preferredNameCounts = new Map<string, number>();
+  for (const candidate of candidates) {
+    preferredNameCounts.set(candidate.preferredName, (preferredNameCounts.get(candidate.preferredName) ?? 0) + 1);
+  }
+  return candidates.map(({ preferredName, ...candidate }) => {
+    const technicalName = extensionFileName(candidate.path);
+    const name = (preferredNameCounts.get(preferredName) ?? 0) === 1 ? preferredName : technicalName;
+    return { ...candidate, name, aliases: [...new Set([name, ...candidate.aliases])] };
+  });
+}

package/extensions/lib/pi-command.ts

@@ -0,0 +1,11 @@
+import { existsSync } from "node:fs";
+
+/**
+ * Return a fresh Pi CLI invocation. Managed Pi upgrades replace release files,
+ * so a long-running worker must not blindly reuse a now-deleted argv[1].
+ */
+export function piCommand(entry = process.argv[1]): { command: string; args: string[] } {
+  return entry && existsSync(entry)
+    ? { command: process.execPath, args: [entry] }
+    : { command: "pi", args: [] };
+}