pi-feats 0.1.4 → 0.1.7

package/extensions/cli-resources.ts

@@ -1,10 +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];
@@ -19,8 +23,6 @@ const kindFromArgs = (args: string[]): ListKind | undefined => {
   return undefined;
 };
 
-const BUILTIN_TOOLS = ["read", "bash", "powershell", "edit", "write", "grep", "find", "ls"] as const;
-
 type Action = "disable" | "enable";
 
 interface ParsedAction {
@@ -64,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 = {
@@ -139,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 {
@@ -178,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 [];
@@ -195,15 +162,18 @@ async function findSkillFiles(path: string): Promise<string[]> {
   return files;
 }
 
-function skillEnabled(resourcePath: string, skillRoot: string, settings: Record<string, unknown>, exclusions: string[]): boolean {
-  const policy = (settings.profile as { enabledSkills?: unknown } | undefined)?.enabledSkills;
+export function skillEnabled(resourcePath: string, sharedSkillRoot: string, profileSkillRoot: string | undefined, settings: Record<string, unknown>, exclusions: string[]): boolean {
+  const isProfileSkill = profileSkillRoot !== undefined && isWithin(resourcePath, profileSkillRoot);
+  const skillRoot = isProfileSkill ? profileSkillRoot! : sharedSkillRoot;
+  const policyKey = isProfileSkill ? "enabledProfileSkills" : "enabledSkills";
+  const policy = (settings.profile as Record<string, unknown> | undefined)?.[policyKey];
   const relativeName = relative(skillRoot, resourcePath).replaceAll("\\", "/");
   const name = relativeName.startsWith("../") ? basename(resourcePath) : relativeName;
   if (Array.isArray(policy)) return policy.includes("*") || policy.includes(name);
   return !isExcluded(resourcePath, exclusions);
 }
 
-async function skillRows(paths: string[], skillRoot: string, settings: Record<string, unknown>, exclusions: string[]): Promise<Row[]> {
+export async function skillRows(paths: string[], sharedSkillRoot: string, profileSkillRoot: string | undefined, settings: Record<string, unknown>, exclusions: string[]): Promise<Row[]> {
   const rows: Row[] = [];
   const seen = new Set<string>();
   for (const path of paths) {
@@ -211,35 +181,42 @@ async function skillRows(paths: string[], skillRoot: string, settings: Record<st
       if (seen.has(skillFile)) continue;
       seen.add(skillFile);
       const resourcePath = dirname(skillFile);
+      const skillRoot = profileSkillRoot !== undefined && isWithin(resourcePath, profileSkillRoot) ? profileSkillRoot : sharedSkillRoot;
       const name = relative(skillRoot, resourcePath).replaceAll("\\", "/");
-      rows.push([name && !name.startsWith("..") ? name : basename(resourcePath), skillEnabled(resourcePath, skillRoot, settings, exclusions) ? "enabled" : "disabled", skillFile]);
+      rows.push([name && !name.startsWith("..") ? name : basename(resourcePath), skillEnabled(resourcePath, sharedSkillRoot, profileSkillRoot, settings, exclusions) ? "enabled" : "disabled", skillFile]);
     }
   }
   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]);
       }
     }
   }
@@ -247,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));
@@ -276,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 : []) {
@@ -288,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>> {
@@ -315,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;
@@ -341,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)) {
@@ -430,20 +435,16 @@ async function applyAction(action: ParsedAction) {
     if (!(BUILTIN_TOOLS as readonly string[]).includes(action.target)) {
       throw new Error(`\"${action.target}\" não é uma tool nativa. Desabilite a extension que fornece essa tool.`);
     }
-    const configured = Array.isArray(settings.defaultTools)
-      ? settings.defaultTools.filter((entry): entry is string => typeof entry === "string")
-      : [...BUILTIN_TOOLS];
-    const updatedTools = enable
-      ? [...new Set([...configured, action.target])]
-      : configured.filter((tool) => tool !== action.target);
-    if (configured.length === updatedTools.length && configured.every((tool, index) => tool === updatedTools[index])) {
+    const configured = activeBuiltinTools(settings);
+    const updatedTools = updatedBuiltinTools(settings, action.target, enable);
+    const effectiveUpdatedTools = updatedTools ?? activeBuiltinTools({});
+    if (configured.length === effectiveUpdatedTools.length && configured.every((tool, index) => tool === effectiveUpdatedTools[index])) {
       console.log(`Tool \"${action.target}\" já está ${enable ? "habilitada" : "desabilitada"}.`);
       return;
     }
-    const updatedSettings: Record<string, unknown> = { ...settings, defaultTools: updatedTools };
-    if (updatedTools.length === BUILTIN_TOOLS.length && BUILTIN_TOOLS.every((tool) => updatedTools.includes(tool))) {
-      delete updatedSettings.defaultTools;
-    }
+    const updatedSettings: Record<string, unknown> = { ...settings };
+    if (updatedTools) updatedSettings.defaultTools = updatedTools;
+    else delete updatedSettings.defaultTools;
     await writeFile(settingsPath, `${JSON.stringify(updatedSettings, null, 2)}\n`, "utf8");
     console.log(`Tool \"${action.target}\" ${enable ? "habilitada" : "desabilitada"} em ${settingsPath}. Use /reload para aplicar.`);
     return;
@@ -452,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")
     : [];
@@ -473,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.
@@ -483,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.
@@ -492,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 } : {}) },
     });
@@ -503,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.");
@@ -542,21 +571,17 @@ 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();
-      const sources = await packageToolSources(resourceRoot, runtimeSettings, pi.getAllTools().map((tool) => tool.name));
+      const sources = await packageToolSources(resourceRoot, runtimeSettings, pi.getAllTools().map((tool) => tool.name).filter((name) => !(BUILTIN_TOOLS as readonly string[]).includes(name)));
       const rows: SourceRow[] = pi.getAllTools()
-        .map((tool) => [tool.name, active.has(tool.name) ? "enabled" : "disabled", sources.has(tool.name) ? `npm: ${sources.get(tool.name)}` : (BUILTIN_TOOLS as readonly string[]).includes(tool.name) ? "Built-in" : "Extension", tool.description] as SourceRow)
+        .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;
@@ -564,18 +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 rows: SourceRow[] = (kind === "skills" ? await skillRows(paths, catalogRoot, settings, exclusions) : await extensionRows(paths, exclusions, (loaded.runtimeSettings.profile as { enabledExtensions?: string[] } | undefined)?.enabledExtensions)).map((row) => {
+      const profileSkillRoot = kind === "skills" && loaded.agentDir !== resourceRoot ? join(loaded.agentDir, "skills") : undefined;
+      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/conversation-search/index.ts

@@ -0,0 +1,42 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { join } from "node:path";
+import { searchConversationEntries, textBlocks, type ConversationCandidate } from "../lib/conversation-search.ts";
+
+const agentDirectory = () => process.env.PI_CODING_AGENT_DIR ?? join(process.env.HOME ?? "", ".pi", "agent");
+const sessionDirectory = () => process.env.PI_ACTIVE_PROFILE && process.env.PI_ACTIVE_PROFILE !== "default" ? join(agentDirectory(), "sessions") : undefined;
+
+export default function registerConversationSearch(pi: ExtensionAPI): void {
+  let currentSessionId: string | undefined;
+  pi.on("session_start", async (_event, ctx) => { currentSessionId = ctx.sessionManager.getSessionId(); });
+  pi.registerTool({
+    name: "conversation_search",
+    label: "Search Previous Conversations",
+    description: "Search previous conversations in the active profile by topic, wording, session name, or session ID. Use this when the user asks what was discussed in another conversation or a previous session; the user does not need to know a session ID. Searches only this profile and never other profiles.",
+    promptSnippet: "Search previous conversations in the active profile by topic, name, or session ID.",
+    promptGuidelines: ["Use conversation_search when the user asks about information discussed in another conversation, a prior session, or asks you to search previous chats. Do not ask for a session ID before searching by topic. When the user supplies a session ID, pass it as sessionId so the exact session is prioritized."],
+    parameters: Type.Object({ query: Type.String({ minLength: 2, description: "Topic, phrase, session name, or session ID to search for in prior conversations." }), sessionId: Type.Optional(Type.String({ minLength: 2, description: "Exact or partial session ID, when the user supplied one." })), limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 10, description: "Maximum number of matching conversations to return." })) }),
+    async execute(_id, params) {
+      const directory = sessionDirectory();
+      const sessions = (await SessionManager.listAll(directory)).filter((session) => session.id !== currentSessionId).sort((left, right) => right.modified.getTime() - left.modified.getTime()).slice(0, 500);
+      const candidates: ConversationCandidate[] = [];
+      for (const session of sessions) {
+        try {
+          const entries = SessionManager.open(session.path, directory, process.cwd()).getBranch().flatMap((entry: any) => {
+            if (entry.type !== "message") return [];
+            const role = entry.message?.role;
+            if (role !== "user" && role !== "assistant") return [];
+            const text = textBlocks(entry.message?.content);
+            return text.trim() ? [{ role, text, timestamp: entry.timestamp }] : [];
+          });
+          if (entries.length) candidates.push({ id: session.id, name: session.name, updatedAt: session.modified, entries });
+        } catch { /* A malformed or concurrently removed session must not block search. */ }
+      }
+      const search = params.sessionId ?? params.query;
+      const results = searchConversationEntries(search, candidates, params.limit ?? 5);
+      const text = results.length ? results.map((result, index) => [`${index + 1}. ${result.name?.trim() || "Untitled conversation"} (${result.id}) — updated ${result.updatedAt.toISOString()}`, ...result.excerpts.map((excerpt) => `   [${excerpt.role}] ${excerpt.text}`)].join("\n")).join("\n\n") : "No previous conversation in this profile matched that topic.";
+      return { content: [{ type: "text" as const, text }], details: { query: search, searchedSessions: sessions.length, matches: results.map((result) => ({ id: result.id, name: result.name ?? null, updatedAt: result.updatedAt.toISOString(), score: result.score })) } };
+    },
+  });
+}

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/builtin-tools.ts

@@ -0,0 +1,24 @@
+export const BUILTIN_TOOLS = ["read", "bash", "powershell", "edit", "write", "grep", "find", "ls"] as const;
+
+// Pi 0.87 enables these four built-ins when settings.defaultTools is absent.
+export const DEFAULT_ACTIVE_BUILTIN_TOOLS = ["read", "bash", "edit", "write"] as const;
+
+type ToolSettings = Record<string, unknown>;
+
+export function activeBuiltinTools(settings: ToolSettings): string[] {
+  const configured = settings.defaultTools;
+  return Array.isArray(configured)
+    ? configured.filter((tool): tool is string => typeof tool === "string")
+    : [...DEFAULT_ACTIVE_BUILTIN_TOOLS];
+}
+
+export function updatedBuiltinTools(settings: ToolSettings, name: string, enabled: boolean): string[] | undefined {
+  const current = activeBuiltinTools(settings);
+  const updated = enabled
+    ? [...new Set([...current, name])]
+    : current.filter((tool) => tool !== name);
+  return updated.length === DEFAULT_ACTIVE_BUILTIN_TOOLS.length
+    && DEFAULT_ACTIVE_BUILTIN_TOOLS.every((tool) => updated.includes(tool))
+    ? undefined
+    : updated;
+}