free-pi-cli 0.3.0 → 0.4.1

package/dist/index.js

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

package/dist/{main-376chsck.js → main-r8jqgh5n.js}

@@ -44,7 +44,7 @@ function openBrowser(url, platform = process.platform, spawnImpl = spawn) {
 // package.json
 var package_default = {
   name: "free-pi-cli",
-  version: "0.3.0",
+  version: "0.4.1",
   description: "Free, ad-supported distribution of the pi coding agent. Inference paid for by ads.",
   license: "MIT",
   type: "module",
@@ -83,6 +83,8 @@ Usage:
   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
 
@@ -97,6 +99,8 @@ 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" };
   }
@@ -163,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
@@ -185,6 +226,9 @@ import {
   createAgentSessionFromServices,
   createAgentSessionRuntime,
   createAgentSessionServices,
+  createCodemodeExtension,
+  createMcpExtension,
+  createToolSearchExtension,
   InteractiveMode,
   SessionManager,
   SettingsManager
@@ -4776,6 +4820,7 @@ var AuthConsentRequestSchema = object({
   consent_version: string2()
 });
 var AccountTierSchema = _enum(["new", "young", "established"]);
+var UsageLaneSchema = _enum(["standard", "fallback", "wait"]);
 var MeResponseSchema = object({
   user_id: string2(),
   handle: string2(),
@@ -4784,7 +4829,12 @@ var MeResponseSchema = object({
   tier: AccountTierSchema,
   credit_usd: number2(),
   notice: string2().optional(),
-  buy_url: string2().optional()
+  buy_url: string2().optional(),
+  allowance_credits: number2().optional(),
+  remaining_credits_today: number2().optional(),
+  refill_at: string2().optional(),
+  lane: UsageLaneSchema.optional(),
+  bonus_credits: number2().optional()
 });
 var MeStatsResponseSchema = object({
   user_id: string2(),
@@ -4795,6 +4845,11 @@ var MeStatsResponseSchema = object({
   remaining_usd_today: number2(),
   credit_usd: number2(),
   credit_credits: number2(),
+  allowance_credits: number2(),
+  remaining_credits_today: number2(),
+  refill_at: string2(),
+  lane: UsageLaneSchema,
+  bonus_credits: number2(),
   request_count_today: number2(),
   prompt_tokens_today: number2(),
   completion_tokens_today: number2(),
@@ -4868,7 +4923,7 @@ function assertExhaustiveErrorCode(code) {
 }
 // ../shared/src/config.ts
 var ConfigSchema = object({
-  perUserDailyCapUsd: number2().default(2.5),
+  perUserDailyCapUsd: number2().default(1.125),
   perUserRollingCapUsd: number2().default(0),
   rollingCapWindowHours: number2().int().default(5),
   globalDailyCapUsd: number2().default(50),
@@ -4892,8 +4947,12 @@ var ConfigSchema = object({
   providerOrder: array(string2()).optional(),
   tierNewMaxDays: number2().int().default(30),
   tierYoungMaxDays: number2().int().default(365),
-  tierCapNewUsd: number2().default(0.5),
-  tierCapYoungUsd: number2().default(2),
+  tierCapNewUsd: number2().default(0.45),
+  tierCapYoungUsd: number2().default(1.125),
+  fallbackLaneUsd: number2().default(0.225),
+  fallbackHourlyCap: number2().int().default(10),
+  fallbackLaneMinHeadroomBps: number2().int().default(1000),
+  queueWaitRetryAfterSeconds: number2().int().default(0),
   sessionLeaseTtlMinutes: number2().int().default(30),
   minCliVersion: string2().default("0.0.0"),
   latestCliVersion: string2().default("0.2.0"),
@@ -4962,6 +5021,10 @@ function loadConfig(env = process.env) {
     tierYoungMaxDays: envNumber(env.TIER_YOUNG_MAX_DAYS),
     tierCapNewUsd: envNumber(env.TIER_CAP_NEW_USD),
     tierCapYoungUsd: envNumber(env.TIER_CAP_YOUNG_USD),
+    fallbackLaneUsd: envNumber(env.FALLBACK_LANE_USD),
+    fallbackHourlyCap: envNumber(env.FALLBACK_HOURLY_CAP),
+    fallbackLaneMinHeadroomBps: envNumber(env.FALLBACK_LANE_MIN_HEADROOM_BPS),
+    queueWaitRetryAfterSeconds: envNumber(env.QUEUE_WAIT_RETRY_AFTER_SECONDS),
     sessionLeaseTtlMinutes: envNumber(env.SESSION_LEASE_TTL_MINUTES),
     minCliVersion: env.MIN_CLI_VERSION || undefined,
     latestCliVersion: env.LATEST_CLI_VERSION || undefined,
@@ -5007,6 +5070,21 @@ var CREDITS_PER_USD = 40000 / 3;
 function usdToCredits(usd) {
   return Math.round(Number(usd) * CREDITS_PER_USD);
 }
+function formatRefillEt(date, timeZone = "America/New_York") {
+  const formatted = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true
+  }).format(date);
+  return `${formatted} ET`;
+}
+function formatCreditsLeftLine(remaining, allowance, refillAt) {
+  const left = remaining.toLocaleString("en-US");
+  const total = allowance.toLocaleString("en-US");
+  return `${left} / ${total} credits left today · refills ${formatRefillEt(refillAt)}`;
+}
+var SLOW_LANE_METER_LINE = "Slow lane: cheapest model until refill";
 // ../pi-ads/src/api.ts
 var REQUEST_TIMEOUT_MS = 3000;
 async function authedFetch(deps, path, init) {
@@ -5113,6 +5191,9 @@ function renderPlainAdLine(creative, clickUrl, theme, columns) {
 function renderErrorLine(message, theme) {
   return theme.fg("error", message);
 }
+function renderWarningLine(message, theme) {
+  return theme.fg("warning", message);
+}
 
 // ../pi-ads/src/banner.ts
 var BANNER_WIDGET_ID = "freepi-ad";
@@ -5180,7 +5261,9 @@ function createInlineRenderer() {
 function mapErrorCode(code) {
   switch (code) {
     case "daily_cap":
-      return "out of free tokens today, resets at 00:00 UTC";
+      return "out of free credits today — refills at UTC midnight";
+    case "queue_wait":
+      return "free-pi is near its daily budget — wait and retry";
     case "rolling_cap":
       return "over the rolling spend cap on the free tier — wait for the Retry-After window";
     case "concurrent":
@@ -5213,6 +5296,13 @@ function inferErrorFromRemainingBudget(remainingUsdToday) {
 
 // ../pi-ads/src/meter.ts
 var METER_WIDGET_ID = "freepi-meter";
+var METER_STATUS_KEY = "freepi-credits";
+var LOW_CREDIT_FRACTION = 0.1;
+var BUY_LINK_TEXT = "freepi.ai/buy";
+function buyMore(buyUrl) {
+  const url = typeof buyUrl === "string" ? sanitizeText(buyUrl) : "";
+  return url !== "" ? ` · Buy more: ${osc8(BUY_LINK_TEXT, url)}` : "";
+}
 var CONFIRM_TURNS = 3;
 var lastCreditUsd;
 var confirm;
@@ -5221,6 +5311,7 @@ function creditAddedMessage(addedUsd) {
 }
 async function renderMeter(deps, ctx) {
   const me = await fetchMe(deps);
+  ctx.ui.setStatus(METER_STATUS_KEY, undefined);
   if (!me) {
     ctx.ui.setWidget(METER_WIDGET_ID, undefined);
     return;
@@ -5242,6 +5333,24 @@ async function renderMeter(deps, ctx) {
     ctx.ui.setWidget(METER_WIDGET_ID, [renderErrorLine(notice, theme)]);
     return;
   }
+  if (me.lane === "fallback") {
+    ctx.ui.setStatus(METER_STATUS_KEY, theme.fg("muted", "0 credits · slow lane"));
+    ctx.ui.setWidget(METER_WIDGET_ID, [
+      renderWarningLine(`Out of free credits — slow lane until refill${buyMore(me.buy_url)}`, theme)
+    ]);
+    return;
+  }
+  if (typeof me.remaining_credits_today === "number" && typeof me.allowance_credits === "number" && typeof me.refill_at === "string") {
+    const refill = new Date(me.refill_at);
+    if (!Number.isNaN(refill.getTime()) && me.lane !== "wait") {
+      const left = me.remaining_credits_today;
+      const bought = typeof me.bonus_credits === "number" && me.bonus_credits > 0 ? ` + ${me.bonus_credits.toLocaleString("en-US")}` : "";
+      ctx.ui.setStatus(METER_STATUS_KEY, theme.fg("muted", `${left.toLocaleString("en-US")}${bought} credits`));
+      const low = left > 0 && left <= me.allowance_credits * LOW_CREDIT_FRACTION;
+      ctx.ui.setWidget(METER_WIDGET_ID, low ? [renderWarningLine(`Low on credits: ${left.toLocaleString("en-US")} left today${buyMore(me.buy_url)}`, theme)] : undefined);
+      return;
+    }
+  }
   const errorCode = inferErrorFromRemainingBudget(me.remaining_usd_today);
   if (errorCode === undefined) {
     ctx.ui.setWidget(METER_WIDGET_ID, undefined);
@@ -5290,7 +5399,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";
@@ -5328,15 +5437,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");
 }
@@ -5346,6 +5478,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,
@@ -5382,12 +5589,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");
 }
@@ -5430,10 +5677,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}$`;
@@ -5475,12 +5753,19 @@ function percentUsed(spentUsd, capUsd) {
 }
 function formatStats(stats) {
   const credits = stats.credit_credits;
+  const remaining = stats.remaining_credits_today;
+  const allowance = stats.allowance_credits;
+  const refillAt = stats.refill_at;
+  const lane = stats.lane;
+  const todayLine = typeof remaining === "number" && typeof allowance === "number" && typeof refillAt === "string" ? formatCreditsLeftLine(remaining, allowance, new Date(refillAt)) : `today: ${percentUsed(stats.spent_usd_today, stats.cap_usd_today)}% of your free daily allowance used`;
   return [
     `tier: ${stats.tier}`,
-    `today: ${percentUsed(stats.spent_usd_today, stats.cap_usd_today)}% of your free daily allowance used`,
+    todayLine,
+    ...lane === "fallback" ? [SLOW_LANE_METER_LINE] : [],
     ...typeof credits === "number" ? [`credit: ${credits.toLocaleString("en-US")} credits remaining`] : [],
     `today tokens: ${stats.prompt_tokens_today} prompt / ${stats.completion_tokens_today} completion`,
-    `lifetime: ${stats.lifetime.prompt_tokens} prompt / ${stats.lifetime.completion_tokens} completion tokens`
+    `lifetime: ${stats.lifetime.prompt_tokens} prompt / ${stats.lifetime.completion_tokens} completion tokens`,
+    "buy more credits: /buy-credits"
   ].join(`
 `);
 }
@@ -5617,6 +5902,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
@@ -5648,6 +5960,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) {
@@ -5703,12 +6266,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" };
@@ -5786,6 +6353,20 @@ function registerBugAutocomplete(pi) {
 
 // src/changelog.ts
 var CHANGELOG_HIGHLIGHTS = [
+  {
+    version: "0.4.1",
+    highlights: [
+      "The footer now shows your credits left, including any you bought. A warning appears when you are low or in the slow lane.",
+      "/usage shows credits left today and when they refill, with /buy-credits to get more."
+    ]
+  },
+  {
+    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: [
@@ -6018,7 +6599,7 @@ function createFreePiCommandsExtension(opts) {
         handler: (_args, ctx) => runUpdate(ctx)
       });
       pi.registerCommand("usage", {
-        description: "Show how much of today's free allowance you have used, and your purchased credit.",
+        description: "Show credits left today, refill time, and purchased credit.",
         handler: (_args, ctx) => showUsage(opts, ctx)
       });
       pi.registerCommand("buy-credits", {
@@ -6043,7 +6624,7 @@ function createFreePiCommandsExtension(opts) {
 
 // src/header.ts
 var COMMANDS = [
-  { name: "/usage", description: "spend and remaining budget today" },
+  { name: "/usage", description: "credits left today and refill time" },
   { name: "/support", description: "visit today's advertiser" },
   { name: "/tos", description: "terms of service" },
   { name: "/privacy-policy", description: "privacy policy" },
@@ -6068,12 +6649,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)
@@ -6084,7 +6665,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 }) => {
@@ -6166,6 +6747,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)
@@ -6173,11 +6796,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",
@@ -6218,6 +6872,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,
@@ -6227,29 +6885,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,
-    tuiMode: "regular",
-    theme: "light/dark",
-    enableInstallTelemetry: false
-  });
+  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) {
@@ -6271,7 +6924,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,
@@ -6280,7 +6935,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);
@@ -6311,7 +6966,7 @@ async function launchPi(opts) {
 }
 
 // src/prompt.ts
-import { createInterface } from "node:readline/promises";
+import { createInterface as createInterface2 } from "node:readline/promises";
 
 // src/consent.ts
 var CONSENT_TEXT = `
@@ -6361,7 +7016,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 {
@@ -6496,12 +7151,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;
@@ -6517,7 +7172,7 @@ function maybeWhatsNew(cliVersion, agentDir) {
   }
 }
 function writeLastSeen(path, version) {
-  mkdirSync(dirname2(path), { recursive: true });
+  mkdirSync(dirname3(path), { recursive: true });
   writeFileSync(path, version, "utf-8");
 }
 
@@ -6706,6 +7361,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.3.0",
+  "version": "0.4.1",
   "description": "Free, ad-supported distribution of the pi coding agent. Inference paid for by ads.",
   "license": "MIT",
   "type": "module",