free-pi-cli 0.2.19 → 0.4.0

package/dist/index.js

@@ -27,4 +27,4 @@ if (err) {
   console.error(err);
   process.exit(1);
 }
-await import("./main-tc7xq892.js");
+await import("./main-nyekh9dy.js");

package/dist/{main-tc7xq892.js → main-nyekh9dy.js}

@@ -44,7 +44,7 @@ function openBrowser(url, platform = process.platform, spawnImpl = spawn) {
 // package.json
 var package_default = {
   name: "free-pi-cli",
-  version: "0.2.19",
+  version: "0.4.0",
   description: "Free, ad-supported distribution of the pi coding agent. Inference paid for by ads.",
   license: "MIT",
   type: "module",
@@ -63,7 +63,7 @@ var package_default = {
     prepublishOnly: "bun run build"
   },
   dependencies: {
-    "@earendil-works/pi-coding-agent": "0.84.4"
+    "@earendil-works/pi-coding-agent": "1.2.0"
   },
   devDependencies: {
     "@freepi/pi-ads": "workspace:*",
@@ -80,10 +80,13 @@ var HELP_TEXT = `
 free-pi — free AI coding in your terminal; ads pay for the inference.
 
 Usage:
-  free-pi-cli            start the coding agent (first run: consent + GitHub sign-in)
-  free-pi-cli logout     remove the stored sign-in token; the next run signs in again
-  free-pi-cli --version  print the CLI version
-  free-pi-cli --help     show this help
+  free-pi-cli                 start the coding agent (first run: consent + GitHub sign-in)
+  free-pi-cli --session <id>  resume a previous session
+  free-pi-cli logout          remove the stored sign-in token; the next run signs in again
+  free-pi-cli mcp <command>   add, remove, list, or sign in to your own MCP servers
+                              (free-pi-cli mcp --help for details)
+  free-pi-cli --version       print the CLI version
+  free-pi-cli --help          show this help
 
 Environment:
   FREEPI_BASE_URL        override the backend base URL (default https://api.freepi.ai)
@@ -96,6 +99,11 @@ function parseCliArgs(argv) {
   const [first, ...rest] = argv;
   if (first === undefined)
     return { kind: "run" };
+  if (first === "mcp")
+    return { kind: "mcp", args: rest };
+  if (first === "--session") {
+    return rest.length > 1 ? { kind: "unknown", arg: rest[1] } : { kind: "run" };
+  }
   let kind;
   if (first === "--help" || first === "-h" || first === "help")
     kind = "help";
@@ -159,21 +167,58 @@ async function runLogout(deps) {
   return 0;
 }
 
+// src/mcp-command.ts
+import { existsSync } from "node:fs";
+import { dirname as dirname2, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+function piMcpCliPath() {
+  return join(dirname2(fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"))), "extensions", "mcp", "cli.js");
+}
+async function loadPiRunner() {
+  const path = piMcpCliPath();
+  if (!existsSync(path)) {
+    throw new Error(`free-pi-cli mcp is unavailable: the bundled pi package has no ${path}. Reinstall free-pi-cli.`);
+  }
+  const mod = await import(pathToFileURL(path).href);
+  if (typeof mod.runMcpCommand !== "function") {
+    throw new Error(`free-pi-cli mcp is unavailable: ${path} does not export runMcpCommand. Reinstall free-pi-cli.`);
+  }
+  return mod.runMcpCommand;
+}
+function brandMcpLine(line) {
+  return line.replace(/\bpi (?=mcp\b)/g, "free-pi-cli ").replace(/~\/\.pi\/agent\b/g, "~/.free-pi/agent").replace(/\b([Ss]tart) pi\b/g, "$1 free-pi-cli");
+}
+async function runFreePiMcp(args, deps) {
+  try {
+    const run = await (deps.loadRunner ?? loadPiRunner)();
+    process.env.PI_CODING_AGENT_DIR = deps.agentDir;
+    return await run(args, {
+      cwd: deps.cwd,
+      agentDir: deps.agentDir,
+      log: (line) => deps.log(brandMcpLine(line)),
+      error: (line) => deps.error(brandMcpLine(line))
+    });
+  } catch (err) {
+    deps.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+
 // src/paths.ts
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 var FREE_PI_DIR_NAME = ".free-pi";
 function getFreePiAgentDir() {
-  return join(homedir(), FREE_PI_DIR_NAME, "agent");
+  return join2(homedir(), FREE_PI_DIR_NAME, "agent");
 }
 function getCredentialsPath(agentDir = getFreePiAgentDir()) {
-  return join(agentDir, "credentials.json");
+  return join2(agentDir, "credentials.json");
 }
 function getLastSeenVersionPath(agentDir = getFreePiAgentDir()) {
-  return join(agentDir, "last-seen-version");
+  return join2(agentDir, "last-seen-version");
 }
 function getConfigPath() {
-  return join(homedir(), FREE_PI_DIR_NAME, "config.json");
+  return join2(homedir(), FREE_PI_DIR_NAME, "config.json");
 }
 
 // src/pi-launch.ts
@@ -181,6 +226,9 @@ import {
   createAgentSessionFromServices,
   createAgentSessionRuntime,
   createAgentSessionServices,
+  createCodemodeExtension,
+  createMcpExtension,
+  createToolSearchExtension,
   InteractiveMode,
   SessionManager,
   SettingsManager
@@ -4851,6 +4899,13 @@ var ClientVersionResponseSchema = object({
 var SessionResetResponseSchema = object({
   released: boolean2()
 });
+var BugReportRequestSchema = object({
+  description: string2().trim().min(1).max(4000),
+  session_id: string2().max(128).optional(),
+  cli_version: string2().max(32).optional(),
+  model: string2().max(128).optional()
+});
+var BugReportResponseSchema = object({ id: string2() });
 // ../shared/src/errors.ts
 function assertExhaustiveErrorCode(code) {
   throw new Error(`unhandled error code: ${String(code)}`);
@@ -4865,6 +4920,8 @@ var ConfigSchema = object({
   accountsPerDayCeiling: number2().int().default(500),
   authRatePerIpPerHour: number2().int().default(30),
   webBuyUrlRatePerProviderPerHour: number2().int().default(20),
+  handoffTokenRatePerProviderPerHour: number2().int().default(60),
+  handoffHourlyCompletionCap: number2().int().default(120),
   tokenRatePerIpPerHour: number2().int().default(3600),
   consentRatePerIpPerHour: number2().int().default(60),
   adInlineTurnFrequency: number2().int().default(5),
@@ -4931,6 +4988,8 @@ function loadConfig(env = process.env) {
     accountsPerDayCeiling: envNumber(env.ACCOUNTS_PER_DAY_CEILING),
     authRatePerIpPerHour: envNumber(env.AUTH_RATE_PER_IP_PER_HOUR),
     webBuyUrlRatePerProviderPerHour: envNumber(env.WEB_BUY_URL_RATE_PER_PROVIDER_PER_HOUR),
+    handoffTokenRatePerProviderPerHour: envNumber(env.HANDOFF_TOKEN_RATE_PER_PROVIDER_PER_HOUR),
+    handoffHourlyCompletionCap: envNumber(env.HANDOFF_HOURLY_COMPLETION_CAP),
     tokenRatePerIpPerHour: envNumber(env.TOKEN_RATE_PER_IP_PER_HOUR),
     consentRatePerIpPerHour: envNumber(env.CONSENT_RATE_PER_IP_PER_HOUR),
     adInlineTurnFrequency: envNumber(env.AD_INLINE_TURN_FREQUENCY),
@@ -5186,6 +5245,8 @@ function mapErrorCode(code) {
       return "too many requests this hour on the free tier — wait for the Retry-After window";
     case "account_review":
       return "this account is under review — contact support";
+    case "ads_required":
+      return "ads aren't displaying for this account, so free completions are paused — run free-pi through `npx free-pi-cli`, then retry";
     default:
       return assertExhaustiveErrorCode(code);
   }
@@ -5273,7 +5334,7 @@ function createAdsExtension(opts) {
 }
 
 // src/pi-launch.ts
-import { join as join2, resolve } from "node:path";
+import { join as join3, resolve as resolve2 } from "node:path";
 
 // src/provider.ts
 var PROVIDER_NAME = "free-pi";
@@ -5311,15 +5372,38 @@ var Metrics = {
   update: 0
 };
 // ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/guard/guard.mjs
+function IsArray(value) {
+  return Array.isArray(value);
+}
+function IsBigInt(value) {
+  return IsEqual(typeof value, "bigint");
+}
+function IsBoolean(value) {
+  return IsEqual(typeof value, "boolean");
+}
 function IsNull(value) {
   return IsEqual(value, null);
 }
+function IsNumber(value) {
+  return Number.isFinite(value);
+}
 function IsObject(value) {
   return IsEqual(typeof value, "object") && !IsNull(value);
 }
+function IsString(value) {
+  return IsEqual(typeof value, "string");
+}
 function IsEqual(left, right) {
   return left === right;
 }
+function IsClassInstance(value) {
+  if (!IsObject(value))
+    return false;
+  const proto = globalThis.Object.getPrototypeOf(value);
+  if (IsNull(proto))
+    return false;
+  return IsEqual(typeof proto.constructor, "function") && !(IsEqual(proto.constructor, globalThis.Object) || IsEqual(proto.constructor.name, "Object"));
+}
 function IsUnsafePropertyKey(key) {
   return IsEqual(key, "__proto__") || IsEqual(key, "constructor") || IsEqual(key, "prototype");
 }
@@ -5329,6 +5413,81 @@ function HasPropertyKey(value, key) {
 function Keys(value) {
   return Object.getOwnPropertyNames(value);
 }
+function Symbols(value) {
+  return Object.getOwnPropertySymbols(value);
+}
+// ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/guard/globals.mjs
+function IsTypeArray(value) {
+  return globalThis.ArrayBuffer.isView(value);
+}
+function IsRegExp(value) {
+  return value instanceof globalThis.RegExp;
+}
+function IsSet(value) {
+  return value instanceof globalThis.Set;
+}
+function IsMap(value) {
+  return value instanceof globalThis.Map;
+}
+// ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/system/memory/clone.mjs
+function FromClassInstance(value) {
+  return value;
+}
+function IsSchemaObject(value) {
+  return HasPropertyKey(value, "~kind") || HasPropertyKey(value, "~unsafe");
+}
+function FromSchemaObject(value) {
+  const result = {};
+  for (const key of Keys(value)) {
+    if (IsUnsafePropertyKey(key))
+      continue;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    descriptor.value = FromValue(descriptor.value);
+    if (IsEqual(descriptor.enumerable, true)) {
+      result[key] = descriptor.value;
+    } else {
+      Object.defineProperty(result, key, descriptor);
+    }
+  }
+  return result;
+}
+function FromPlainObject(value) {
+  const result = {};
+  for (const key of Keys(value)) {
+    if (IsUnsafePropertyKey(key))
+      continue;
+    result[key] = FromValue(value[key]);
+  }
+  for (const key of Symbols(value)) {
+    result[key] = FromValue(value[key]);
+  }
+  return result;
+}
+function FromObject(value) {
+  return IsClassInstance(value) ? FromClassInstance(value) : IsSchemaObject(value) ? FromSchemaObject(value) : FromPlainObject(value);
+}
+function FromArray(value) {
+  return value.map((element) => FromValue(element));
+}
+function FromTypedArray(value) {
+  return value.slice();
+}
+function FromRegExp(value) {
+  return new RegExp(value.source, value.flags);
+}
+function FromMap(value) {
+  return new Map(FromValue([...value.entries()]));
+}
+function FromSet(value) {
+  return new Set(FromValue([...value.values()]));
+}
+function FromValue(value) {
+  return IsTypeArray(value) ? FromTypedArray(value) : IsRegExp(value) ? FromRegExp(value) : IsMap(value) ? FromMap(value) : IsSet(value) ? FromSet(value) : IsArray(value) ? FromArray(value) : IsObject(value) ? FromObject(value) : value;
+}
+function Clone(value) {
+  Metrics.clone += 1;
+  return FromValue(value);
+}
 // ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/system/settings/settings.mjs
 var settings = {
   immutableTypes: false,
@@ -5365,12 +5524,52 @@ function Create(hidden, enumerable, options = {}) {
   const withHidden = settings.enumerableKind ? Merge(withOptions, hidden) : MergeHidden(withOptions, hidden);
   return settings.immutableTypes ? Object.freeze(withHidden) : withHidden;
 }
+// ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/system/memory/update.mjs
+function Update(current, hidden, enumerable) {
+  Metrics.update += 1;
+  const settings = Get();
+  const result = Clone(current);
+  for (const key of Object.keys(hidden)) {
+    Object.defineProperty(result, key, {
+      configurable: true,
+      writable: true,
+      enumerable: settings.enumerableKind,
+      value: hidden[key]
+    });
+  }
+  for (const key of Object.keys(enumerable)) {
+    Object.defineProperty(result, key, {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: enumerable[key]
+    });
+  }
+  return result;
+}
 // ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/type/types/schema.mjs
 function IsSchema(value) {
   return IsObject(value);
 }
 
+// ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/type/engine/optional/instantiate_add.mjs
+function AddOptionalOperation(type) {
+  return Update(type, { "~optional": true }, {});
+}
+function AddOptionalAction(type, options) {
+  const result = Update(AddOptionalOperation(type), {}, options);
+  return result;
+}
+
+// ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/type/action/_add_optional.mjs
+function AddOptional(type, options = {}) {
+  return AddOptionalAction(type, options);
+}
+
 // ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/type/types/_optional.mjs
+function Optional(type) {
+  return AddOptional(type);
+}
 function IsOptional(value) {
   return IsSchema(value) && HasPropertyKey(value, "~optional");
 }
@@ -5413,10 +5612,41 @@ var F64Out = new Uint8Array(F64.buffer);
 var encoder = new TextEncoder;
 // ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/type/types/integer.mjs
 var IntegerPattern = "-?(?:0|[1-9][0-9]*)";
+// ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/type/types/literal.mjs
+class InvalidLiteralValue extends Error {
+  constructor(value) {
+    super(`Invalid Literal value`);
+    Object.defineProperty(this, "cause", {
+      value: { value },
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+}
+function LiteralTypeName(value) {
+  return IsBigInt(value) ? "bigint" : IsBoolean(value) ? "boolean" : IsNumber(value) ? "number" : IsString(value) ? "string" : (() => {
+    throw new InvalidLiteralValue(value);
+  })();
+}
+function Literal(value, options) {
+  return Create({ "~kind": "Literal" }, { type: LiteralTypeName(value), const: value }, options);
+}
 // ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/type/types/number.mjs
 var NumberPattern = "-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?";
+function Number2(options) {
+  return Create({ "~kind": "Number" }, { type: "number" }, options);
+}
 // ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/type/types/string.mjs
 var StringPattern = ".*";
+function String2(options) {
+  return Create({ "~kind": "String" }, { type: "string" }, options);
+}
+
+// ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/type/types/union.mjs
+function Union(anyOf, options = {}) {
+  return Create({ "~kind": "Union" }, { anyOf }, options);
+}
 
 // ../../node_modules/.bun/typebox@1.3.16/node_modules/typebox/build/type/types/record.mjs
 var IntegerKey = `^${IntegerPattern}$`;
@@ -5573,9 +5803,10 @@ exciting models. Ads shown in the terminal pay for it. You never handle a
 model API key. Config and the sign-in token live under \`~/.free-pi/agent\`,
 separate from any \`~/.pi/agent\` install.
 
-## The promise
-Ad text never enters the model's context. Ads render only in the terminal,
-in a framed card, and the model never sees them.
+## Ads and your data
+Ads render in the terminal, in a framed card. Some ads come from Gravity, a
+third-party ad provider that receives excerpts of your recent conversation
+to pick a relevant ad.
 Coding sessions may be used to train models. This is on the consent screen
 at first run, before the GitHub sign-in.
 
@@ -5599,6 +5830,33 @@ first. Purchased credits cover use beyond it and do not expire.
 - \`/close-other-session\` — free a stuck session on another machine
 - \`/update\` — get the latest free-pi
 - \`/whats-new\` — what changed in recent releases
+- \`/todos\` — show the agent's todo list
+- \`/mcp\` — manage your MCP servers (connect, sign in, turn on or off)
+
+## Todo list
+The agent keeps its own todo list with the \`todo\` tool, to track multi-step
+work. While any item is open, the list shows live above the input box, and
+each todo change prints a progress line in the conversation. \`/todos\` shows
+the full list. The list belongs to the session and comes back when you resume
+it.
+
+## MCP servers
+MCP (Model Context Protocol) servers give the agent extra tools, such as a
+database, a browser, or an internal API. free-pi includes none; you add your
+own. The agent reaches their tools by writing a short script for its
+\`codemode\` tool.
+Servers live in \`~/.free-pi/agent/mcp.json\`. A project can have its own
+\`.pi/mcp.json\`; it is read only after you trust the project when asked.
+Add a server from a shell, or ask the agent to run the command for you with
+its bash tool:
+\`free-pi-cli mcp add files -- npx -y @modelcontextprotocol/server-filesystem .\`
+\`free-pi-cli mcp add docs --url https://example.com/mcp\`
+Other commands: \`free-pi-cli mcp list\` (add \`--json\` for machine output),
+\`free-pi-cli mcp remove <server>\`, \`free-pi-cli mcp login <server>\` to sign
+in to a server that uses OAuth, and \`free-pi-cli mcp logout <server>\`. Add
+\`-l\` to add or remove in the current project instead of globally.
+Inside a session, \`/mcp\` shows each server and its tools, and lets you sign
+in, reconnect, or turn a server on or off.
 
 ## Support
 Today's sponsor keeps free-pi free. When the user asks how to help the
@@ -5630,6 +5888,257 @@ function createDocsToolExtension() {
   };
 }
 
+// src/todo-view.ts
+var PLAIN_STYLE = { bold: (s) => s, dim: (s) => s, accent: (s) => s, error: (s) => s };
+var GAP = "  ";
+function truncate2(text, max) {
+  if (max <= 0)
+    return "";
+  if ([...text].length <= max)
+    return text;
+  return [...text].slice(0, Math.max(0, max - 1)).join("") + "…";
+}
+function counts(todos) {
+  return { done: todos.filter((t) => t.done).length, total: todos.length };
+}
+function widgetLines(todos, width, st = PLAIN_STYLE) {
+  if (todos.length === 0)
+    return [];
+  const { done, total } = counts(todos);
+  const header = `Todos ${done}/${total}`;
+  const firstOpen = todos.findIndex((t) => !t.done);
+  const marks = todos.map((t, i) => t.done ? `✓ ${t.text}` : i === firstOpen ? `▸ ${t.text}` : `○ ${t.text}`);
+  const compactLength = [...[header, ...marks].join(GAP)].length;
+  if (compactLength <= width) {
+    return [
+      [
+        st.bold(header),
+        ...todos.map((t, i) => t.done ? st.dim(marks[i]) : i === firstOpen ? st.accent(st.bold(marks[i])) : st.dim(marks[i]))
+      ].join(GAP)
+    ];
+  }
+  const lines = [st.bold(truncate2(header, width))];
+  const open = todos.filter((t) => !t.done);
+  if (open.length === 0) {
+    lines.push(st.dim(truncate2("✓ All done", width)));
+    return lines;
+  }
+  open.slice(0, 3).forEach((t, i) => {
+    const line = truncate2(`${i === 0 ? "▸" : "○"} ${t.text}`, width);
+    lines.push(i === 0 ? st.accent(st.bold(line)) : st.dim(line));
+  });
+  const more = open.length - 3;
+  if (more > 0)
+    lines.push(st.dim(truncate2(`+${more} more · /todos for all`, width)));
+  return lines;
+}
+function resultLines(d, st = PLAIN_STYLE) {
+  if (d.error)
+    return [st.error(`Error: ${d.error}`)];
+  if (d.action === "clear")
+    return [`${st.accent("●")} ${st.bold("todo")} cleared`];
+  const { done, total } = counts(d.todos);
+  const head = `${st.accent("●")} ${st.bold("todo")} ${done}/${total}`;
+  let first = head;
+  if (d.item && d.action === "add")
+    first = `${head}${GAP}+ ${d.item.text}`;
+  if (d.item && d.action === "toggle")
+    first = `${head}${GAP}${d.item.done ? "✓" : "○"} ${d.item.text}`;
+  const lines = [first];
+  const next = d.todos.find((t) => !t.done);
+  if ((d.action === "add" || d.action === "toggle") && next && next.id !== d.item?.id)
+    lines.push(st.dim(`${GAP}next: ${next.text}`));
+  return lines;
+}
+
+// src/todo-tool.ts
+var TODO_TOOL_NAME = "todo";
+var TODO_WIDGET_ID = "freepi-todo";
+var TODO_ENTRY_TYPE = "free-pi-todo";
+var ALL_DONE_LINGER_MS = 3000;
+var REASSERT_ORDER_MS = 15000;
+var realTimers = {
+  setTimeout: (fn, ms) => {
+    const h = setTimeout(fn, ms);
+    h.unref?.();
+    return h;
+  },
+  clearTimeout: (h) => clearTimeout(h),
+  setInterval: (fn, ms) => {
+    const h = setInterval(fn, ms);
+    h.unref?.();
+    return h;
+  },
+  clearInterval: (h) => clearInterval(h)
+};
+var PARAMS4 = _Object_({
+  action: Union([Literal("list"), Literal("add"), Literal("toggle"), Literal("clear")]),
+  text: Optional(String2({ description: "Todo text (for add)" })),
+  id: Optional(Number2({ description: "Todo ID (for toggle)" }))
+});
+function asSnapshot(value) {
+  const v = value;
+  if (!v || !Array.isArray(v.todos) || typeof v.nextId !== "number")
+    return;
+  return { todos: v.todos, nextId: v.nextId };
+}
+function formatTodos(todos) {
+  return todos.length ? todos.map((t) => `[${t.done ? "x" : " "}] #${t.id}: ${t.text}`).join(`
+`) : "No todos";
+}
+function styleFrom(theme) {
+  return {
+    bold: (s) => theme.bold(s),
+    dim: (s) => theme.fg("dim", s),
+    accent: (s) => theme.fg("accent", s),
+    error: (s) => theme.fg("error", s)
+  };
+}
+function createTodoToolExtension(options = {}) {
+  const timers = options.timers ?? realTimers;
+  return {
+    name: "free-pi-todo",
+    factory(pi) {
+      let todos = [];
+      let nextId = 1;
+      let widgetCtx;
+      let lingerTimer;
+      let orderTimer;
+      const stopTimers = () => {
+        if (lingerTimer !== undefined)
+          timers.clearTimeout(lingerTimer);
+        if (orderTimer !== undefined)
+          timers.clearInterval(orderTimer);
+        lingerTimer = orderTimer = undefined;
+      };
+      const hideWidget = () => {
+        stopTimers();
+        try {
+          widgetCtx?.ui.setWidget(TODO_WIDGET_ID, undefined);
+        } catch {}
+      };
+      const showWidget = () => {
+        try {
+          widgetCtx?.ui.setWidget(TODO_WIDGET_ID, (_tui, theme) => {
+            const style = styleFrom(theme);
+            return {
+              render: (width) => widgetLines(todos, Math.max(1, width - 2), style).map((l) => ` ${l}`),
+              invalidate() {}
+            };
+          });
+        } catch {}
+      };
+      const refreshWidget = (ctx, replay = false) => {
+        if (ctx?.mode !== "tui")
+          return;
+        widgetCtx = ctx;
+        const hasOpen = todos.some((t) => !t.done);
+        if (todos.length === 0 || !hasOpen && replay) {
+          hideWidget();
+          return;
+        }
+        if (lingerTimer !== undefined) {
+          timers.clearTimeout(lingerTimer);
+          lingerTimer = undefined;
+        }
+        showWidget();
+        if (orderTimer === undefined)
+          orderTimer = timers.setInterval(showWidget, REASSERT_ORDER_MS);
+        if (!hasOpen) {
+          lingerTimer = timers.setTimeout(() => {
+            lingerTimer = undefined;
+            hideWidget();
+          }, ALL_DONE_LINGER_MS);
+        }
+      };
+      const reconstructState = (ctx) => {
+        todos = [];
+        nextId = 1;
+        for (const entry of ctx.sessionManager.getBranch()) {
+          let snap;
+          if (entry.type === "custom" && entry.customType === TODO_ENTRY_TYPE)
+            snap = asSnapshot(entry.data);
+          else if (entry.type === "message" && entry.message.role === "toolResult" && entry.message.toolName === TODO_TOOL_NAME)
+            snap = asSnapshot(entry.message.details);
+          if (snap) {
+            todos = snap.todos.map((t) => ({ ...t }));
+            nextId = snap.nextId;
+          }
+        }
+        refreshWidget(ctx, true);
+      };
+      pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
+      pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
+      pi.on("session_shutdown", async () => {
+        stopTimers();
+        widgetCtx = undefined;
+      });
+      const result = (ctx, text, action, error, item) => {
+        const snapshot = { todos: todos.map((t) => ({ ...t })), nextId };
+        if (action !== "list" && !error)
+          pi.appendEntry(TODO_ENTRY_TYPE, snapshot);
+        if (action !== "list" && !error)
+          refreshWidget(ctx);
+        return {
+          content: [{ type: "text", text }],
+          details: { action, ...snapshot, ...item ? { item: { ...item } } : {}, ...error ? { error } : {} }
+        };
+      };
+      pi.registerTool({
+        name: TODO_TOOL_NAME,
+        label: "Todo",
+        description: "Manage a todo list. Actions: list, add (text), toggle (id), clear",
+        promptSnippet: "Track your own multi-step work in a todo list: add items, toggle them done, list them",
+        parameters: PARAMS4,
+        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+          switch (params.action) {
+            case "list":
+              return result(ctx, formatTodos(todos), "list");
+            case "add": {
+              if (!params.text)
+                return result(ctx, "Error: text required for add", "add", "text required");
+              const todo = { id: nextId++, text: params.text, done: false };
+              todos.push(todo);
+              return result(ctx, `Added todo #${todo.id}: ${todo.text}`, "add", undefined, todo);
+            }
+            case "toggle": {
+              if (params.id === undefined)
+                return result(ctx, "Error: id required for toggle", "toggle", "id required");
+              const todo = todos.find((t) => t.id === params.id);
+              if (!todo)
+                return result(ctx, `Todo #${params.id} not found`, "toggle", `#${params.id} not found`);
+              todo.done = !todo.done;
+              return result(ctx, `Todo #${todo.id} ${todo.done ? "completed" : "uncompleted"}`, "toggle", undefined, todo);
+            }
+            case "clear": {
+              const count = todos.length;
+              todos = [];
+              nextId = 1;
+              return result(ctx, `Cleared ${count} todos`, "clear");
+            }
+            default:
+              return result(ctx, `Unknown action: ${String(params.action)}`, "list", "unknown action");
+          }
+        },
+        renderCall() {
+          return { render: () => [], invalidate() {} };
+        },
+        renderResult(res, _opts, theme) {
+          const details = res.details;
+          const lines = details?.action ? resultLines(details, styleFrom(theme)) : [res.content[0]?.type === "text" ? res.content[0].text : ""];
+          return { render: () => lines, invalidate() {} };
+        }
+      });
+      pi.registerCommand("todos", {
+        description: "Show all todos on the current branch",
+        handler: async (_args, ctx) => {
+          ctx.ui.notify(formatTodos(todos), "info");
+        }
+      });
+    }
+  };
+}
+
 // src/error-notice.ts
 var NOTICE_DEDUPE_MS = 15000;
 function parseErrorEnvelope(errorMessage) {
@@ -5685,12 +6194,16 @@ async function reportToolGuardTrigger(opts, toolName) {
     });
   } catch {}
 }
+var MCP_RESOURCE_TOOLS = ["list_mcp_resources", "list_mcp_resource_templates", "read_mcp_resource"];
+function isAllowed(opts, name) {
+  return opts.allowedTools.includes(name) || name.startsWith("mcp__") || MCP_RESOURCE_TOOLS.includes(name);
+}
 function createToolGuardExtension(opts) {
   return {
     name: "free-pi-tool-guard",
     factory(pi) {
       pi.on("tool_call", (event) => {
-        if (opts.allowedTools.includes(event.toolName))
+        if (isAllowed(opts, event.toolName))
           return;
         reportToolGuardTrigger(opts, event.toolName);
         return { block: true, reason: "tool not permitted in the free-pi distro" };
@@ -5699,8 +6212,90 @@ function createToolGuardExtension(opts) {
   };
 }
 
+// src/bug-report.ts
+var BUG_USAGE = "Usage: /bug <what went wrong>";
+var BUG_DESCRIPTION = "Report a bug to free-pi";
+function buildBugRequest(description, ctx) {
+  return { description, session_id: ctx.sessionId, cli_version: CLI_VERSION, model: ctx.model };
+}
+function mapBugFailure(status) {
+  if (status === 401)
+    return "Couldn't send the bug report: you're signed out. Restart free-pi-cli to sign in again.";
+  if (status === 429)
+    return "Couldn't send the bug report: you've reached today's limit of 20 reports. Try again tomorrow.";
+  if (status === 413)
+    return "Couldn't send the bug report: it is too large.";
+  if (status === 400)
+    return "Couldn't send the bug report: the description is too long (4000 characters max).";
+  return `Couldn't send the bug report (the server returned ${status}). Try again in a moment.`;
+}
+async function sendBugReport(opts, body) {
+  try {
+    const res = await (opts.fetchImpl ?? fetch)(`${opts.baseUrl}/bug-reports`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${await opts.getToken()}`, "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok)
+      return { ok: false, message: mapBugFailure(res.status) };
+    const parsed = BugReportResponseSchema.safeParse(await res.json());
+    if (!parsed.success)
+      return { ok: false, message: mapBugFailure(res.status) };
+    return { ok: true, id: parsed.data.id };
+  } catch {
+    return { ok: false, message: "Couldn't reach free-pi to send the bug report — check your connection." };
+  }
+}
+function makeBugHandler(mode, opts) {
+  return async (hint) => {
+    if (!hint)
+      return mode.showStatus(BUG_USAGE);
+    const r = await sendBugReport(opts, buildBugRequest(hint, { sessionId: mode.session.sessionId, model: mode.session.model?.id }));
+    if (r.ok)
+      return mode.showStatus(`Thanks — bug report received (#${r.id}).`);
+    if (!mode.editor.getText())
+      mode.editor.setText(`/bug ${hint}`);
+    mode.showError(r.message);
+  };
+}
+function installBugHandler(mode, opts) {
+  mode.handleBugCommand = makeBugHandler(mode, opts);
+}
+function registerBugAutocomplete(pi) {
+  pi.on("session_start", (_event, ctx) => {
+    ctx.ui.addAutocompleteProvider((cur) => ({
+      triggerCharacters: cur.triggerCharacters,
+      applyCompletion: (...a) => cur.applyCompletion(...a),
+      shouldTriggerFileCompletion: cur.shouldTriggerFileCompletion?.bind(cur),
+      getSuggestions: async (...a) => {
+        const r = await cur.getSuggestions(...a);
+        return r && {
+          ...r,
+          items: r.items.map((i) => i.value === "bug" && i.label === "bug" ? { ...i, description: BUG_DESCRIPTION } : i)
+        };
+      }
+    }));
+  });
+}
+
 // src/changelog.ts
 var CHANGELOG_HIGHLIGHTS = [
+  {
+    version: "0.4.0",
+    highlights: [
+      "The agent now keeps a todo list for multi-step work: it shows live above the input box, and /todos shows the full list.",
+      "Add your own MCP servers: `npx free-pi-cli mcp add`, then /mcp in a session to manage them."
+    ]
+  },
+  {
+    version: "0.3.0",
+    highlights: [
+      "Upgraded the underlying pi agent engine to 1.2.0.",
+      "/bug now sends reports to the free-pi team.",
+      "`npx free-pi-cli --session <id>` resumes a session again."
+    ]
+  },
   {
     version: "0.2.19",
     highlights: [
@@ -5911,6 +6506,7 @@ function createFreePiCommandsExtension(opts) {
   return {
     name: "free-pi-commands",
     factory(pi) {
+      registerBugAutocomplete(pi);
       pi.registerCommand("close-other-session", {
         description: "Clear your other running free-pi session (use if a previous one is stuck).",
         handler: (_args, ctx) => closeOtherSession(opts, ctx)
@@ -5974,12 +6570,12 @@ function updateBannerLines(theme, latest, width) {
   return [
     "",
     border,
-    theme.bold(theme.fg("warning", truncate2(headline, inner))),
-    theme.fg("dim", truncate2(detail, inner)),
+    theme.bold(theme.fg("warning", truncate3(headline, inner))),
+    theme.fg("dim", truncate3(detail, inner)),
     border
   ];
 }
-function truncate2(text, maxWidth) {
+function truncate3(text, maxWidth) {
   if (maxWidth <= 0)
     return "";
   if (text.length <= maxWidth)
@@ -5990,7 +6586,7 @@ function truncate2(text, maxWidth) {
 }
 function headerLines(theme, modelName, expanded, width = Number.POSITIVE_INFINITY, updateLatest) {
   const inner = width - 1;
-  const fit = (plain, styled) => plain.length <= inner ? styled() : theme.fg("dim", truncate2(plain, inner));
+  const fit = (plain, styled) => plain.length <= inner ? styled() : theme.fg("dim", truncate3(plain, inner));
   const titleRest = ` · ${modelName} · ctrl+o for help`;
   const title = fit(`free-pi${titleRest}`, () => `${theme.bold(theme.fg("accent", "free-pi"))}${theme.fg("dim", titleRest)}`);
   const commandLines = COMMANDS.map(({ name, description }) => {
@@ -6054,7 +6650,7 @@ function resolveFreePiScope(modelRuntime, providerName, modelIds, env = process.
 
 // src/resume-line.ts
 var RESUME_LABEL = "To resume this session:";
-var RESUME_COMMAND_RE = /(To resume this session:(?:\u001b\[[0-9;]*m|\s)*)pi(?=\s)/g;
+var RESUME_COMMAND_RE = /(To resume this session:(?:\u001b\[[0-9;]*m|\s)*)pi(?=\s)( --session-dir (?:'(?:[^']|'\\'')*'|\S+))?/g;
 function rewriteResumeLine(chunk) {
   if (!chunk.includes(RESUME_LABEL))
     return chunk;
@@ -6072,6 +6668,48 @@ function patchResumeLine(stream) {
   };
 }
 
+// src/project-trust.ts
+import { createInterface } from "node:readline/promises";
+import { resolve } from "node:path";
+import { hasTrustRequiringProjectResources, ProjectTrustStore } from "@earendil-works/pi-coding-agent";
+var PROJECT_TRUST_PROMPT = "This folder has project settings for free-pi (.pi/ or .agents/skills), which can run code such as MCP servers and extensions. Trust this folder? [y/N] ";
+async function decideProjectTrust(cwd, agentDir, deps) {
+  if (!(deps.hasTrustRequiringResources ?? hasTrustRequiringProjectResources)(cwd))
+    return true;
+  const store = new ProjectTrustStore(agentDir);
+  const saved = store.get(cwd);
+  if (typeof saved === "boolean")
+    return saved;
+  if (!deps.stdinIsTTY) {
+    deps.log("This folder has project settings (.pi/ or .agents/skills); they are ignored because it is not trusted.");
+    return false;
+  }
+  const decision = /^y(es)?$/i.test((await deps.askLine(PROJECT_TRUST_PROMPT)).trim());
+  store.set(cwd, decision);
+  return decision;
+}
+function decideProjectTrustInteractive(cwd, agentDir) {
+  return decideProjectTrust(cwd, agentDir, {
+    stdinIsTTY: process.stdin.isTTY === true,
+    log: (message) => console.log(message),
+    askLine: async (prompt) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try {
+        return await rl.question(prompt);
+      } finally {
+        rl.close();
+      }
+    }
+  });
+}
+function projectTrustForCwd(cwd, launch, agentDir, hasTrustRequiringResources = hasTrustRequiringProjectResources) {
+  if (resolve(cwd) === resolve(launch.cwd))
+    return launch.trusted;
+  if (!hasTrustRequiringResources(cwd))
+    return true;
+  return new ProjectTrustStore(agentDir).get(cwd) === true;
+}
+
 // src/pi-launch.ts
 function catalogModelsFor(opts) {
   if (opts.models && opts.models.length > 0)
@@ -6079,11 +6717,42 @@ function catalogModelsFor(opts) {
   const id = opts.model || MODEL_ID;
   return [{ id, name: id }];
 }
-var ALLOWED_TOOL_NAMES = [...SAFE_TOOLS, USAGE_TOOL_NAME, BUY_TOOL_NAME, DOCS_TOOL_NAME];
+var ALLOWED_TOOL_NAMES = [
+  ...SAFE_TOOLS,
+  USAGE_TOOL_NAME,
+  BUY_TOOL_NAME,
+  DOCS_TOOL_NAME,
+  TODO_TOOL_NAME,
+  "codemode",
+  "tool_search"
+];
+var SDK_TOOLS = [
+  ...ALLOWED_TOOL_NAMES,
+  "mcp__*",
+  "list_mcp_resources",
+  "list_mcp_resource_templates",
+  "read_mcp_resource"
+];
 function resolveModelName(opts) {
   return opts.models?.[0]?.name || opts.model || MODEL_ID;
 }
+function buildSettingsManager(opts, models, projectTrusted) {
+  return SettingsManager.inMemory({
+    defaultProvider: PROVIDER_NAME,
+    defaultModel: models[0].id,
+    defaultTools: [...SAFE_TOOLS, TODO_TOOL_NAME],
+    packages: [],
+    quietStartup: true,
+    tuiMode: "regular",
+    theme: "light/dark",
+    enableInstallTelemetry: false
+  }, { projectTrusted });
+}
+function settingsForRuntime(opts, rtCwd, launch) {
+  return buildSettingsManager(opts, catalogModelsFor(opts), projectTrustForCwd(rtCwd, launch, opts.agentDir));
+}
 function buildRuntimeOptions(opts, sessionId) {
+  process.env.PI_CODING_AGENT_DIR = opts.agentDir;
   const models = catalogModelsFor(opts);
   const providerExtension = {
     name: "free-pi-provider",
@@ -6124,6 +6793,10 @@ function buildRuntimeOptions(opts, sessionId) {
     modelName: resolveModelName(opts),
     updateLatest: opts.updateLatest
   });
+  const todoToolExtension = createTodoToolExtension();
+  const mcpExtension = { name: "pi-mcp", factory: createMcpExtension() };
+  const codemodeExtension = { name: "pi-codemode", factory: createCodemodeExtension({ models: false }) };
+  const toolSearchExtension = { name: "pi-tool-search", factory: createToolSearchExtension() };
   const extensionFactories = [
     providerExtension,
     adsExtension,
@@ -6133,26 +6806,24 @@ function buildRuntimeOptions(opts, sessionId) {
     errorNoticeExtension,
     toolGuardExtension,
     commandsExtension,
-    headerExtension
+    headerExtension,
+    todoToolExtension,
+    mcpExtension,
+    codemodeExtension,
+    toolSearchExtension
   ];
-  const settingsManager = SettingsManager.inMemory({
-    defaultProvider: PROVIDER_NAME,
-    defaultModel: models[0].id,
-    defaultTools: [...SAFE_TOOLS],
-    packages: [],
-    quietStartup: true
-  });
+  const settingsManager = buildSettingsManager(opts, models, opts.projectTrusted === true);
   return {
     settingsManager,
     resourceLoaderOptions: { extensionFactories },
     extensionNames: extensionFactories.map((e) => e.name),
-    tools: ALLOWED_TOOL_NAMES
+    tools: SDK_TOOLS
   };
 }
 function getSessionDir(cwd, agentDir) {
-  const resolvedCwd = resolve(cwd);
+  const resolvedCwd = resolve2(cwd);
   const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-  return join2(resolve(agentDir), "sessions", safePath);
+  return join3(resolve2(agentDir), "sessions", safePath);
 }
 async function createSessionManager(cwd, sessionDir, sessionId, api = SessionManager) {
   if (sessionId) {
@@ -6166,6 +6837,7 @@ async function createSessionManager(cwd, sessionDir, sessionId, api = SessionMan
   return api.create(cwd, sessionDir);
 }
 process.env.PI_SKIP_VERSION_CHECK = "1";
+process.env.PI_TELEMETRY = "0";
 patchResumeLine(process.stdout);
 async function launchPi(opts) {
   const cwd = process.cwd();
@@ -6173,7 +6845,9 @@ async function launchPi(opts) {
   const sm = await createSessionManager(cwd, sessionDir, opts.session);
   const sessionId = sm.getSessionId();
   const scopeIds = catalogModelsFor(opts).map((m) => m.id);
-  const { settingsManager, resourceLoaderOptions, tools } = buildRuntimeOptions(opts, sessionId);
+  const projectTrusted = await decideProjectTrustInteractive(cwd, opts.agentDir);
+  const { resourceLoaderOptions, tools } = buildRuntimeOptions({ ...opts, projectTrusted }, sessionId);
+  const launchTrust = { cwd, trusted: projectTrusted };
   const createRuntime = async ({
     cwd: rtCwd,
     sessionManager,
@@ -6182,7 +6856,7 @@ async function launchPi(opts) {
     const services = await createAgentSessionServices({
       cwd: rtCwd,
       agentDir: opts.agentDir,
-      settingsManager,
+      settingsManager: settingsForRuntime(opts, rtCwd, launchTrust),
       resourceLoaderOptions
     });
     const scopedModels = resolveFreePiScope(services.modelRuntime, PROVIDER_NAME, scopeIds);
@@ -6207,20 +6881,22 @@ async function launchPi(opts) {
     initialImages: [],
     initialMessages: []
   });
+  installBugHandler(mode, { baseUrl: opts.baseUrl, getToken: () => opts.jwt });
   await mode.run();
   return sm.getSessionId();
 }
 
 // src/prompt.ts
-import { createInterface } from "node:readline/promises";
+import { createInterface as createInterface2 } from "node:readline/promises";
 
 // src/consent.ts
 var CONSENT_TEXT = `
 free-pi — before you start
 
   * Inference is free. Ads pay for it, and so does training.
-  * Ad cards render in the terminal UI. Ad content never enters the model's
-    context.
+  * Ad cards render in the terminal UI. Some ads come from a third-party ad
+    provider (Gravity), which receives excerpts of your recent conversation
+    to pick a relevant ad.
   * Your coding sessions (prompts, code, files, and model responses) are saved
     as traces and used to train models. We may share or sell that data to
     third parties. Once you accept, there is no opt-out, except where the law
@@ -6239,7 +6915,7 @@ and the Privacy Policy (https://freepi.ai/privacy).
 
 Decline and nothing is sent to the free-pi server.
 `.trim();
-var CONSENT_VERSION = "2";
+var CONSENT_VERSION = "3";
 var NON_INTERACTIVE_CONSENT_TEXT = "free-pi first-run consent needs an interactive terminal (stdin is not a TTY). " + "Run `npx free-pi-cli` in a terminal once to review and accept; " + "after that, non-interactive runs work.";
 var CONSENT_PROMPT = "Accept? [y/N] ";
 function parseConsentAnswer(answer) {
@@ -6261,7 +6937,7 @@ async function promptConsentInteractive() {
     stdinIsTTY: process.stdin.isTTY === true,
     log: (message) => console.log(message),
     askLine: async (prompt) => {
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const rl = createInterface2({ input: process.stdin, output: process.stdout });
       try {
         return await rl.question(prompt);
       } finally {
@@ -6396,12 +7072,12 @@ ${INTRO_TEXT}
 }
 
 // src/whats-new.ts
-import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname as dirname3 } from "node:path";
 function maybeWhatsNew(cliVersion, agentDir) {
   try {
     const path = getLastSeenVersionPath(agentDir);
-    const lastSeen = existsSync(path) ? readFileSync2(path, "utf-8").trim() : undefined;
+    const lastSeen = existsSync2(path) ? readFileSync2(path, "utf-8").trim() : undefined;
     writeLastSeen(path, cliVersion);
     if (lastSeen === undefined)
       return;
@@ -6417,7 +7093,7 @@ function maybeWhatsNew(cliVersion, agentDir) {
   }
 }
 function writeLastSeen(path, version) {
-  mkdirSync(dirname2(path), { recursive: true });
+  mkdirSync(dirname3(path), { recursive: true });
   writeFileSync(path, version, "utf-8");
 }
 
@@ -6606,6 +7282,15 @@ ${HELP_TEXT}`);
     });
     process.exit(logoutCode);
   }
+  if (command.kind === "mcp") {
+    const mcpCode = await runFreePiMcp(command.args, {
+      cwd: process.cwd(),
+      agentDir: getFreePiAgentDir(),
+      log: (line) => console.log(line),
+      error: (line) => console.error(line)
+    });
+    process.exit(mcpCode);
+  }
   const agentDir = getFreePiAgentDir();
   const code = await run({
     baseUrl: resolveBaseUrl(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-pi-cli",
-  "version": "0.2.19",
+  "version": "0.4.0",
   "description": "Free, ad-supported distribution of the pi coding agent. Inference paid for by ads.",
   "license": "MIT",
   "type": "module",
@@ -19,7 +19,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "0.84.4"
+    "@earendil-works/pi-coding-agent": "1.2.0"
   },
   "devDependencies": {
     "@freepi/pi-ads": "workspace:*",