localpi 0.5.2 → 0.6.0

package/dist/src/localpi/options.js

@@ -1,5 +1,10 @@
 import path from "node:path";
 import { normalizeBaseUrl } from "../llm/openai.js";
+export const statsModes = ["off", "line", "full"];
+export const skillsModes = ["own", "ambient", "off"];
+export const permissionModes = ["ask", "allow"];
+// localpi launches Pi through npx, so a normal launch always runs the newest Pi release.
+const defaultPiCommand = "npx -y @earendil-works/pi-coding-agent@latest";
 export const thinkingLevels = [
     "off",
     "minimal",
@@ -23,10 +28,13 @@ export function defaultOptions() {
         modelThinkingFormat: envOptionalThinkingFormat("LOCALPI_MODEL_THINKING_FORMAT", "LOCALPAGER_AGENT_THINKING_FORMAT"),
         stateDir,
         sessionDir: defaultSessionDir(stateDir),
-        piCommand: envString("LOCALPI_PI_CMD", "npx -y @earendil-works/pi-coding-agent@latest"),
+        piCommand: parsePiCommand(envString("LOCALPI_PI_CMD", defaultPiCommand)),
         thinking: parseThinkingLevel(envString("LOCALPI_THINKING", "medium")),
+        thinkingBudget: envOptionalThinkingBudget("LOCALPI_THINKING_BUDGET"),
+        thinkingBudgetMessage: process.env["LOCALPI_THINKING_BUDGET_MESSAGE"],
         contextWindow: envOptionalPositiveInteger("LOCALPI_CONTEXT_WINDOW"),
         maxTokens: envPositiveInteger("LOCALPI_MAX_TOKENS", "8192"),
+        continueOnTruncation: envContinuationLimit("LOCALPI_CONTINUE_ON_TRUNCATION"),
         timeoutMs: envPositiveInteger("LOCALPI_TIMEOUT_MS", "3000"),
         serverCommand: envString("LOCALPI_LLAMA_SERVER", "llama-server"),
         host: envString("LOCALPI_HOST", "127.0.0.1"),
@@ -36,13 +44,17 @@ export function defaultOptions() {
         chatTemplate: process.env["LOCALPI_CHAT_TEMPLATE"],
         tools: envString("LOCALPI_TOOLS", "read,bash,edit,write,grep,find,ls"),
         approval: envBoolean("LOCALPI_APPROVAL", true),
-        tokenStatus: envBoolean("LOCALPI_TOKEN_STATUS", true),
+        approveReadTools: envBoolean("LOCALPI_APPROVE_READ_TOOLS", false),
+        stats: defaultStatsMode(),
+        skills: parseSkillsMode(envString("LOCALPI_SKILLS", "own")),
         demo: envBoolean("LOCALPI_DEMO", false),
         demoFromCli: false,
         demoInitialPrompt: process.env["LOCALPI_DEMO_INITIAL_PROMPT"],
         demoInitialPromptFile: process.env["LOCALPI_DEMO_INITIAL_PROMPT_FILE"],
         demoFollowupPrompt: process.env["LOCALPI_DEMO_FOLLOWUP_PROMPT"],
         demoFollowupPromptFile: process.env["LOCALPI_DEMO_FOLLOWUP_PROMPT_FILE"],
+        acp: envBoolean("LOCALPI_ACP", false),
+        acpFromCli: false,
         status: false,
         stop: false,
         list: false,
@@ -84,13 +96,16 @@ export function usage() {
         "  localpi [localpi options] [pi options/messages]",
         "",
         "localpi options:",
-        "  --runtime <kind>         auto, llama-server, lmstudio, vllm, or openai-compatible",
+        "  --runtime <kind>         auto, llama-server, llama-cpp, lmstudio, vllm, or openai-compatible",
         "  --provider <id>          catalog provider id to use",
         "  --model <alias|id|path>  model alias, backend id, or GGUF path",
         "  --base-url <url>         OpenAI-compatible endpoint",
         "  --ctx <n>                model context window",
         "  --context-window <n>     alias for --ctx",
         "  --max-tokens <n>         generated model max output tokens",
+        "  --continue-on-truncation <n>",
+        "                          continue a reply cut off by the output limit, up to n times",
+        "                          (LOCALPI_CONTINUE_ON_TRUNCATION=<n>)",
         "  --server-command <path>  llama-server executable",
         "  --llama-server <path>    alias for --server-command",
         "  --host <host>            managed llama-server host",
@@ -99,13 +114,18 @@ export function usage() {
         "  --parallel <n>           llama-server parallel slots",
         "  --chat-template <path>   llama.cpp chat template file",
         "  --tools <list>           Pi tools allow list",
+        "  --stats <mode>           stats: off, line, or full (default: full)",
+        "  --skills <mode>          skills: own, ambient, or off (default: own)",
         "  --providers-file <path>  localpi provider registry JSON",
         "  --model-profile <path>   local model capability profile JSON",
         "  --model-reasoning <bool> override generated Pi reasoning capability",
         "  --model-thinking-format <format>",
         "                          override generated Pi thinking format",
-        "  --no-approval           do not ask before tool calls",
-        "  --no-token-status       do not install token status extension",
+        "  --no-approval           start with tool approval off for this session",
+        "  --approve-read-tools    also ask before read-only tools (read, grep, find, ls)",
+        "  --no-token-status       alias for --stats off",
+        "  --acp                   serve ACP on stdio through the pinned pi-acp adapter",
+        "                          (LOCALPI_ACP=1); requires an explicit --model",
         "  --demo                  endlessly run Pi prompts for demo mode",
         "  --demo-initial-prompt <text>",
         "                          first demo prompt",
@@ -120,8 +140,11 @@ export function usage() {
         "  --list                  list model aliases",
         "  --state-dir <path>      localpi runtime state directory",
         "  --session-dir <path>    Pi session directory",
-        "  --pi-command <command>  Pi launch command",
+        "  --pi-command <command>  Pi launch command, split on whitespace and quotes",
         "  --thinking <level>      thinking level: off, minimal, low, medium, high, xhigh",
+        "  --thinking-budget <n>   managed llama-server thinking cap in tokens, -1 for unrestricted",
+        "  --thinking-budget-message <text>",
+        "                          text before the end-of-thinking tag; empty text passes none",
         "  --timeout-ms <n>        backend probe timeout",
         "  -h, --help              show this help",
         "",
@@ -156,7 +179,11 @@ const booleanFlagUpdaters = {
     "--stop": (options) => ({ ...options, stop: true }),
     "--list": (options) => ({ ...options, list: true }),
     "--no-approval": (options) => ({ ...options, approval: false }),
-    "--no-token-status": (options) => ({ ...options, tokenStatus: false }),
+    "--approve-read-tools": (options) => ({ ...options, approveReadTools: true }),
+    "--no-token-status": (options) => ({ ...options, stats: "off" }),
+    "--no-skills": (options) => ({ ...options, skills: "off" }),
+    "-ns": (options) => ({ ...options, skills: "off" }),
+    "--acp": (options) => ({ ...options, acp: true, acpFromCli: true }),
     "--demo": (options) => ({ ...options, demo: true, demoFromCli: true })
 };
 const valueFlagUpdaters = {
@@ -174,14 +201,28 @@ const valueFlagUpdaters = {
     }),
     "--state-dir": (options, value) => ({ ...options, stateDir: value }),
     "--session-dir": (options, value) => ({ ...options, sessionDir: value }),
-    "--pi-command": (options, value) => ({ ...options, piCommand: value }),
+    "--pi-command": (options, value) => ({ ...options, piCommand: parsePiCommand(value) }),
     "--thinking": (options, value) => ({ ...options, thinking: parseThinkingLevel(value) }),
+    "--thinking-budget": (options, value) => ({
+        ...options,
+        thinkingBudget: parseThinkingBudget(value)
+    }),
+    "--thinking-budget-message": (options, value) => ({
+        ...options,
+        thinkingBudgetMessage: value
+    }),
+    "--stats": (options, value) => ({ ...options, stats: parseStatsMode(value) }),
+    "--skills": (options, value) => ({ ...options, skills: parseSkillsMode(value) }),
     "--ctx": (options, value) => ({ ...options, contextWindow: parsePositiveInteger(value) }),
     "--context-window": (options, value) => ({
         ...options,
         contextWindow: parsePositiveInteger(value)
     }),
     "--max-tokens": (options, value) => ({ ...options, maxTokens: parsePositiveInteger(value) }),
+    "--continue-on-truncation": (options, value) => ({
+        ...options,
+        continueOnTruncation: parsePositiveInteger(value)
+    }),
     "--timeout-ms": (options, value) => ({ ...options, timeoutMs: parsePositiveInteger(value) }),
     "--server-command": (options, value) => ({ ...options, serverCommand: value }),
     "--llama-server": (options, value) => ({ ...options, serverCommand: value }),
@@ -243,12 +284,13 @@ function normalizeDemoPromptPrecedence(options, tracker) {
 function parseRuntime(value) {
     if (value === "auto" ||
         value === "llama-server" ||
+        value === "llama-cpp" ||
         value === "lmstudio" ||
         value === "vllm" ||
         value === "openai-compatible") {
         return value;
     }
-    throw new Error(`unknown runtime ${value}; expected auto, llama-server, lmstudio, vllm, or openai-compatible`);
+    throw new Error(`unknown runtime ${value}; expected auto, llama-server, llama-cpp, lmstudio, vllm, or openai-compatible`);
 }
 export function parseThinkingLevel(value) {
     for (const level of thinkingLevels) {
@@ -258,6 +300,66 @@ export function parseThinkingLevel(value) {
     }
     throw new Error(`unknown thinking level ${value}; expected off, minimal, low, medium, high, or xhigh`);
 }
+/**
+ * A thinking budget is -1 for unrestricted thinking, or a positive token count. Zero is rejected,
+ * because the managed server reads it as an immediate end of thinking.
+ */
+export function parseThinkingBudget(value) {
+    if (/^[1-9]\d*$/u.test(value)) {
+        return Number.parseInt(value, 10);
+    }
+    if (value === "-1") {
+        return -1;
+    }
+    throw new Error(`unknown thinking budget ${value}; expected -1 or a positive integer`);
+}
+export function parseStatsMode(value) {
+    for (const mode of statsModes) {
+        if (value === mode) {
+            return mode;
+        }
+    }
+    throw new Error(`unknown stats mode ${value}; expected off, line, or full`);
+}
+export function parseSkillsMode(value) {
+    for (const mode of skillsModes) {
+        if (value === mode) {
+            return mode;
+        }
+    }
+    throw new Error(`unknown skills mode ${value}; expected own, ambient, or off`);
+}
+export function parsePermissionMode(value) {
+    for (const mode of permissionModes) {
+        if (value === mode) {
+            return mode;
+        }
+    }
+    throw new Error(`unknown permission mode ${value}; expected ask or allow`);
+}
+/**
+ * Split a Pi launch command into a program and its arguments. Quotes group words, so a quoted
+ * argument stays one piece.
+ */
+export function parsePiCommand(value) {
+    const parts = (value.match(/"[^"]*"|'[^']*'|\S+/gu) ?? []).map(unquotePiCommandPart);
+    if (parts.length === 0) {
+        throw new Error("Pi launch command must not be empty");
+    }
+    return parts;
+}
+function unquotePiCommandPart(part) {
+    const quote = part[0];
+    const quoted = part.length > 1 && (quote === '"' || quote === "'");
+    return quoted && part.endsWith(quote) ? part.slice(1, -1) : part;
+}
+function defaultStatsMode() {
+    const explicit = process.env["LOCALPI_STATS"];
+    if (explicit !== undefined) {
+        return parseStatsMode(explicit);
+    }
+    return envBoolean("LOCALPI_TOKEN_STATUS", true) ? "full" : "off";
+}
 function parseModelThinkingFormat(value) {
     if (value === "deepseek" || value === "qwen-chat-template") {
         return value;
@@ -281,6 +383,24 @@ function envOptionalPositiveInteger(name) {
     const value = process.env[name];
     return value === undefined ? undefined : parsePositiveInteger(value);
 }
+/**
+ * The continuation limit allows zero, because zero turns the feature off. An inherited
+ * environment value must be disableable without dropping the variable.
+ */
+function envContinuationLimit(name) {
+    const value = process.env[name];
+    if (value === undefined) {
+        return 0;
+    }
+    if (!/^(0|[1-9]\d*)$/u.test(value)) {
+        throw new Error(`${name} must be a nonnegative integer, got ${value}`);
+    }
+    return Number.parseInt(value, 10);
+}
+function envOptionalThinkingBudget(name) {
+    const value = process.env[name];
+    return value === undefined ? undefined : parseThinkingBudget(value);
+}
 function envOptionalBoolean(primaryName, fallbackName) {
     const [name, value] = envFirst([primaryName, fallbackName]);
     return value === undefined ? undefined : parseBoolean(value, name);

package/dist/src/localpi/provider-registry.js

@@ -12,6 +12,8 @@ export async function providerConfigs(options) {
             return [lmStudioProvider(options.baseUrl)];
         case "vllm":
             return [vllmProvider(options.baseUrl)];
+        case "llama-cpp":
+            return [llamaCppProvider(options.baseUrl)];
         case "openai-compatible": {
             const providerId = options.provider ?? options.customProviderId;
             return [
@@ -31,6 +33,7 @@ export async function providerConfigs(options) {
 function autoProviderConfigs(options, configured) {
     const managedBaseUrl = llamaBaseUrl(options);
     return dedupeProviderConfigs([
+        llamaCppProvider(),
         lmStudioProvider(),
         vllmProvider(),
         ...configured,
@@ -60,6 +63,50 @@ function vllmProvider(baseUrl = "http://127.0.0.1:8000/v1") {
         discover: true
     };
 }
+function llamaCppProvider(baseUrl = defaultLlamaCppBaseUrl()) {
+    return {
+        id: "llama-cpp",
+        name: "llama.cpp",
+        type: "llama-cpp",
+        baseUrl: normalizeBaseUrl(baseUrl),
+        discover: true
+    };
+}
+// llama.cpp is localpi's default engine. Its endpoint is probed first so a loaded
+// llama.cpp model wins the automatic selection ahead of other local engines.
+export function defaultLlamaCppBaseUrl() {
+    return "http://127.0.0.1:8080/v1";
+}
+// Known engines for the built-in openai-compatible providers. A configured openai-compatible
+// provider gets no entry, because its engine is unknown.
+const builtInEngineLabels = {
+    lmstudio: "LM Studio",
+    vllm: "vLLM"
+};
+/**
+ * Map localpi providers to the inference engine that serves them. Only providers whose engine is
+ * known appear in the result, so callers never show a guessed engine name.
+ */
+export function engineEntries(providers) {
+    const engines = new Map();
+    for (const provider of providers) {
+        const engine = engineLabel(provider);
+        if (engine !== undefined && !engines.has(provider.id)) {
+            engines.set(provider.id, engine);
+        }
+    }
+    return [...engines].map(([provider, engine]) => ({ provider, engine }));
+}
+function engineLabel(provider) {
+    switch (provider.type) {
+        case "llama-cpp":
+            return "llama.cpp";
+        case "managed-llama-server":
+            return "llama-server";
+        case "openai-compatible":
+            return builtInEngineLabels[provider.id];
+    }
+}
 function managedLlamaProvider() {
     return {
         id: "llama-server",
@@ -84,10 +131,11 @@ async function configuredProviderConfigs(options) {
 function configuredProvider(id, value) {
     const entry = asObject(value, `provider ${id}`);
     const type = optionalString(entry["type"]);
-    if (type !== "openai-compatible") {
-        throw new Error(`provider ${id} type must be openai-compatible`);
+    if (type !== "openai-compatible" && type !== "llama-cpp") {
+        throw new Error(`provider ${id} type must be openai-compatible or llama-cpp`);
     }
-    const baseUrl = optionalString(entry["baseUrl"]);
+    const baseUrl = optionalString(entry["baseUrl"]) ??
+        (type === "llama-cpp" ? defaultLlamaCppBaseUrl() : undefined);
     if (baseUrl === undefined) {
         throw new Error(`provider ${id} must define baseUrl`);
     }

package/dist/src/localpi/runtime-connection.js

@@ -1,13 +1,14 @@
+import { paint } from "./catppuccin.js";
 import { formatCatalogWarning, managedCapabilityConfig } from "./catalog.js";
 export function connectionStatus(connection) {
     return ([
-        `runtime: ${connection.runtime}`,
-        `provider: ${connection.providerId}`,
-        `base url: ${connection.baseUrl}`,
-        `model: ${connection.model}`,
-        `available models: ${connection.availableModels.join(", ")}`,
-        `context window: ${String(connection.contextWindow ?? "unspecified")}`,
-        ...connection.warnings.map((warning) => `warning: ${warning}`)
+        `${paint("runtime:", "overlay1")} ${connection.runtime}`,
+        `${paint("provider:", "overlay1")} ${connection.providerId}`,
+        `${paint("base url:", "overlay1")} ${connection.baseUrl}`,
+        `${paint("model:", "overlay1")} ${connection.model}`,
+        `${paint("available models:", "overlay1")} ${connection.availableModels.join(", ")}`,
+        `${paint("context window:", "overlay1")} ${String(connection.contextWindow ?? "unspecified")}`,
+        ...connection.warnings.map((warning) => `${paint("warning:", "peach")} ${warning}`)
     ].join("\n") + "\n");
 }
 export function statusModelList(models) {
@@ -67,7 +68,9 @@ function connectionRuntimeName(selected) {
     if (selected.runtime === "managed-llama-server") {
         return "llama-server";
     }
-    return selected.providerId === "lmstudio" || selected.providerId === "vllm"
+    return selected.providerId === "lmstudio" ||
+        selected.providerId === "vllm" ||
+        selected.providerId === "llama-cpp"
         ? selected.providerId
         : selected.runtime;
 }

package/dist/src/localpi/runtime.js

@@ -1,8 +1,10 @@
 import { discoverModelCatalog, formatCatalogWarning } from "./catalog.js";
+import { paint } from "./catppuccin.js";
 import { llamaBaseUrl, llamaServerStatus, stopManagedLlamaServer } from "./llama-server.js";
 import { listModelAliases } from "./models.js";
 import { catalogRuntimeConnection, connectionStatus, statusModelList } from "./runtime-connection.js";
 import { resolveLlamaRuntime, resolveSelectedLlamaRuntime } from "./managed-runtime.js";
+import { defaultLlamaCppBaseUrl } from "./provider-registry.js";
 import { selectCatalogModel } from "./runtime-selection.js";
 export { connectionStatus } from "./runtime-connection.js";
 export async function resolveRuntime(options) {
@@ -12,10 +14,9 @@ export async function resolveRuntime(options) {
     switch (options.runtime) {
         case "llama-server":
             return resolveLlamaRuntime(options);
+        case "llama-cpp":
         case "lmstudio":
-            return resolveCatalogRuntime(options);
         case "vllm":
-            return resolveCatalogRuntime(options);
         case "openai-compatible":
             return resolveCatalogRuntime(options);
     }
@@ -23,6 +24,7 @@ export async function resolveRuntime(options) {
 export async function stopRuntime(options) {
     if (options.runtime === "lmstudio" ||
         options.runtime === "vllm" ||
+        options.runtime === "llama-cpp" ||
         options.runtime === "openai-compatible") {
         return `runtime ${options.runtime} is externally managed; nothing stopped`;
     }
@@ -72,10 +74,10 @@ async function catalogStatusOutput(options) {
     const loaded = catalog.models.filter((model) => model.availability === "loaded");
     const startable = catalog.models.filter((model) => model.availability === "startable");
     return ([
-        `runtime: ${options.runtime}`,
-        `loaded models: ${statusModelList(loaded)}`,
-        `startable models: ${statusModelList(startable)}`,
-        ...catalog.warnings.map((warning) => `warning: ${formatCatalogWarning(warning)}`)
+        `${paint("runtime:", "overlay1")} ${options.runtime}`,
+        `${paint("loaded models:", "overlay1")} ${statusModelList(loaded)}`,
+        `${paint("startable models:", "overlay1")} ${statusModelList(startable)}`,
+        ...catalog.warnings.map((warning) => `${paint("warning:", "peach")} ${formatCatalogWarning(warning)}`)
     ].join("\n") + "\n");
 }
 function requiredOpenAiBaseUrl(options) {
@@ -85,5 +87,8 @@ function requiredOpenAiBaseUrl(options) {
     return options.baseUrl;
 }
 function defaultExternalBaseUrl(runtime) {
-    return runtime === "vllm" ? "http://127.0.0.1:8000/v1" : "http://127.0.0.1:1234/v1";
+    if (runtime === "vllm") {
+        return "http://127.0.0.1:8000/v1";
+    }
+    return runtime === "llama-cpp" ? defaultLlamaCppBaseUrl() : "http://127.0.0.1:1234/v1";
 }

package/dist/src/localpi/settings-state.js

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { asObject, optionalString } from "../common/json.js";
-import { parseThinkingLevel } from "./options.js";
+import { parsePermissionMode, parseStatsMode, parseThinkingLevel } from "./options.js";
 export function localpiSettingsPath(options) {
     return path.join(options.stateDir, "settings.json");
 }
@@ -9,7 +9,11 @@ export async function applyRememberedSettings(options, explicit) {
     const settings = await readLocalpiSettings(options);
     return {
         ...options,
-        thinking: explicit.thinking || settings.thinking === undefined ? options.thinking : settings.thinking
+        thinking: explicit.thinking || settings.thinking === undefined ? options.thinking : settings.thinking,
+        stats: explicit.stats || settings.stats === undefined ? options.stats : settings.stats,
+        approval: explicit.permission || settings.permission === undefined
+            ? options.approval
+            : settings.permission === "ask"
     };
 }
 async function readLocalpiSettings(options) {
@@ -26,7 +30,13 @@ async function readLocalpiSettings(options) {
     try {
         const root = asObject(JSON.parse(raw), "localpi settings");
         const thinking = optionalString(root["thinking"]);
-        return thinking === undefined ? {} : { thinking: parseThinkingLevel(thinking) };
+        const stats = optionalString(root["stats"]);
+        const permission = optionalString(root["permission"]);
+        return {
+            ...(thinking === undefined ? {} : { thinking: parseThinkingLevel(thinking) }),
+            ...(stats === undefined ? {} : { stats: parseStatsMode(stats) }),
+            ...(permission === undefined ? {} : { permission: parsePermissionMode(permission) })
+        };
     }
     catch {
         return {};

package/dist/src/pi/app.js

@@ -1,3 +1,5 @@
+import { localpiThemeArgs } from "./theme.js";
+import { localpiSkillsArgs } from "./skills.js";
 import { localpiVersion } from "./version.js";
 const localpiAppIdentity = {
     id: "localpi",
@@ -16,11 +18,11 @@ const demoLaunchOverrideBooleanFlags = new Set([
 ]);
 const demoLaunchOverrideValueFlags = new Set(["--tools", "-t", "--exclude-tools", "-xt"]);
 const demoLaunchOverrideEqualsFlags = ["--tools=", "--exclude-tools="];
-export function createLocalpiAppDefinition(options, connection, extensions) {
+export function createLocalpiAppDefinition(options, connection, extensions, themePath) {
     return {
         ...localpiAppIdentity,
         ...appDirectories(options),
-        ...piCommand(options),
+        ...piCommand(options, themePath),
         ...runtimeSelection(options, connection),
         ...extensionConfig(extensions)
     };
@@ -31,10 +33,14 @@ function appDirectories(options) {
         sessionDir: options.sessionDir
     };
 }
-function piCommand(options) {
+function piCommand(options, themePath) {
     return {
         piCommand: options.piCommand,
-        forwardedArgs: options.demo ? demoForwardedArgs(options.forwardedArgs) : options.forwardedArgs
+        forwardedArgs: [
+            ...localpiSkillsArgs(options.skills, options.stateDir),
+            ...localpiThemeArgs(themePath, options.forwardedArgs),
+            ...(options.demo ? demoForwardedArgs(options.forwardedArgs) : options.forwardedArgs)
+        ]
     };
 }
 function demoForwardedArgs(args) {
@@ -105,7 +111,7 @@ function modelDefinition(options, model) {
         name: model.displayName,
         reasoning: model.reasoning ?? false,
         ...(model.thinkingFormat === undefined ? {} : { thinkingFormat: model.thinkingFormat }),
-        input: ["text"],
+        input: model.capabilities.includes("image") ? ["text", "image"] : ["text"],
         ...(contextWindow === undefined ? {} : { contextWindow }),
         ...(model.maxTokens === undefined
             ? { maxTokens: options.maxTokens }

package/dist/src/pi/extension-sources/continue-on-truncation.js

@@ -0,0 +1,55 @@
+/**
+ * Continue a reply that the model cut off at the declared output limit.
+ *
+ * Pi ends the agent run when a turn stops at the output cap without asking for a tool, so a
+ * half-written reply becomes the whole answer. This extension asks the model to continue after
+ * such a turn, at most `limit` times per session. The limit lives in the generated source, so the
+ * extension carries no extra environment variable into the Pi child.
+ */
+export function continueOnTruncationExtensionSource(limit) {
+    return `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const limit = ${String(limit)};
+
+const nudge = [
+  "You hit the output limit before finishing.",
+  "Continue from where you stopped.",
+  "Do not repeat earlier text. Take the next tool call or write the answer."
+].join(" ");
+
+export default function localpiContinueOnTruncation(pi: ExtensionAPI): void {
+  let continued = 0;
+  let limitReported = false;
+
+  pi.on("session_start", () => {
+    continued = 0;
+    limitReported = false;
+  });
+
+  pi.on("turn_end", (event) => {
+    if (event.message.role !== "assistant" || event.message.stopReason !== "length") {
+      return;
+    }
+    // A turn that already asked for tools keeps running on its own.
+    if (event.toolResults.length > 0) {
+      return;
+    }
+    if (continued >= limit) {
+      if (!limitReported) {
+        limitReported = true;
+        const plural = continued === 1 ? "" : "s";
+        process.stderr.write(
+          \`localpi: reply was cut off again after \${continued} continuation\${plural}; stopping now\\n\`
+        );
+      }
+      return;
+    }
+    continued += 1;
+    process.stderr.write(
+      \`localpi: reply was cut off by the output limit; continuing (\${continued}/\${limit})\\n\`
+    );
+    pi.sendUserMessage(nudge, { deliverAs: "followUp" });
+  });
+}
+`;
+}

package/dist/src/pi/extension-sources/settings-file.js

@@ -0,0 +1,31 @@
+// Generated Pi extensions are standalone files, so they cannot import from each other. Both the
+// stats extension and the approval extension read and write the localpi settings file, so they
+// embed this one snippet instead of keeping two copies of the same code.
+//
+// The embedding extension must import `mkdir`, `readFile`, and `writeFile` from `node:fs/promises`
+// and `dirname` from `node:path`.
+export function settingsFileSource(settingsPath) {
+    const settingsPathSource = JSON.stringify(settingsPath);
+    return `const settingsPath = ${settingsPathSource};
+
+async function readSettings(): Promise<Record<string, unknown>> {
+  try {
+    const parsed: unknown = JSON.parse(await readFile(settingsPath, "utf8"));
+    return settingsRecord(parsed) ?? {};
+  } catch {
+    return {};
+  }
+}
+
+async function writeSettings(settings: Record<string, unknown>): Promise<void> {
+  await mkdir(dirname(settingsPath), { recursive: true });
+  await writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+}
+
+function settingsRecord(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+`;
+}