@psnext/slingcli 2.5.20260617-2 → 2.5.20260623-1

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/loader.js

@@ -7,7 +7,7 @@ import { createRequire } from "node:module";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import * as _bundledPiAgentCore from "@earendil-works/pi-agent-core";
-import * as _bundledPiAi from "@earendil-works/pi-ai";
+import * as _bundledPiAiCompat from "@earendil-works/pi-ai/compat";
 import * as _bundledPiAiOauth from "@earendil-works/pi-ai/oauth";
 import * as _bundledPiTui from "@earendil-works/pi-tui";
 import { createJiti } from "jiti/static";
@@ -35,12 +35,17 @@ const VIRTUAL_MODULES = {
     "@sinclair/typebox/value": _bundledTypeboxValue,
     "@earendil-works/pi-agent-core": _bundledPiAgentCore,
     "@earendil-works/pi-tui": _bundledPiTui,
-    "@earendil-works/pi-ai": _bundledPiAi,
+    // Extensions resolve the pi-ai root to the compat entrypoint (a strict
+    // superset of the core entrypoint): existing extensions using the old
+    // global API keep working at runtime until compat is removed.
+    "@earendil-works/pi-ai": _bundledPiAiCompat,
+    "@earendil-works/pi-ai/compat": _bundledPiAiCompat,
     "@earendil-works/pi-ai/oauth": _bundledPiAiOauth,
     "@earendil-works/pi-coding-agent": _bundledPiCodingAgent,
     "@mariozechner/pi-agent-core": _bundledPiAgentCore,
     "@mariozechner/pi-tui": _bundledPiTui,
-    "@mariozechner/pi-ai": _bundledPiAi,
+    "@mariozechner/pi-ai": _bundledPiAiCompat,
+    "@mariozechner/pi-ai/compat": _bundledPiAiCompat,
     "@mariozechner/pi-ai/oauth": _bundledPiAiOauth,
     "@mariozechner/pi-coding-agent": _bundledPiCodingAgent,
 };
@@ -69,18 +74,23 @@ function getAliases() {
     const piCodingAgentEntry = packageIndex;
     const piAgentCoreEntry = resolveWorkspaceOrImport("agent/dist/index.js", "@earendil-works/pi-agent-core");
     const piTuiEntry = resolveWorkspaceOrImport("tui/dist/index.js", "@earendil-works/pi-tui");
-    const piAiEntry = resolveWorkspaceOrImport("ai/dist/index.js", "@earendil-works/pi-ai");
+    // Extensions resolve the pi-ai root to the compat entrypoint (a strict
+    // superset of the core entrypoint): existing extensions using the old
+    // global API keep working at runtime until compat is removed.
+    const piAiCompatEntry = resolveWorkspaceOrImport("ai/dist/compat.js", "@earendil-works/pi-ai/compat");
     const piAiOauthEntry = resolveWorkspaceOrImport("ai/dist/oauth.js", "@earendil-works/pi-ai/oauth");
     _aliases = {
         "@earendil-works/pi-coding-agent": piCodingAgentEntry,
         "@earendil-works/pi-agent-core": piAgentCoreEntry,
         "@earendil-works/pi-tui": piTuiEntry,
-        "@earendil-works/pi-ai": piAiEntry,
+        "@earendil-works/pi-ai": piAiCompatEntry,
+        "@earendil-works/pi-ai/compat": piAiCompatEntry,
         "@earendil-works/pi-ai/oauth": piAiOauthEntry,
         "@mariozechner/pi-coding-agent": piCodingAgentEntry,
         "@mariozechner/pi-agent-core": piAgentCoreEntry,
         "@mariozechner/pi-tui": piTuiEntry,
-        "@mariozechner/pi-ai": piAiEntry,
+        "@mariozechner/pi-ai": piAiCompatEntry,
+        "@mariozechner/pi-ai/compat": piAiCompatEntry,
         "@mariozechner/pi-ai/oauth": piAiOauthEntry,
         typebox: typeboxEntry,
         "typebox/compile": typeboxCompileEntry,
@@ -91,6 +101,22 @@ function getAliases() {
     };
     return _aliases;
 }
+let extensionCacheCwd;
+let extensionCacheGeneration = 0;
+const extensionCache = new Map();
+export function clearExtensionCache() {
+    extensionCache.clear();
+    extensionCacheCwd = undefined;
+    extensionCacheGeneration++;
+}
+function useExtensionCacheCwd(cwd) {
+    const resolvedCwd = resolvePath(cwd);
+    if (extensionCacheCwd !== undefined && extensionCacheCwd !== resolvedCwd) {
+        clearExtensionCache();
+    }
+    extensionCacheCwd = resolvedCwd;
+    return { cwd: resolvedCwd, generation: extensionCacheGeneration };
+}
 /**
  * Create a runtime with throwing stubs for action methods.
  * Runner.bindCore() replaces these with real implementations.
@@ -127,7 +153,7 @@ export function createExtensionRuntime() {
         invalidate: (message) => {
             state.staleMessage ??=
                 message ??
-                    "This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().";
+                    "This extension ctx is stale after session replacement or reload. Do not use a captured sling or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().";
         },
         // Pre-bind: queue registrations so bindCore() can flush them once the
         // model registry is available. bindCore() replaces both with direct calls.
@@ -261,7 +287,18 @@ function createExtensionAPI(extension, runtime, cwd, eventBus) {
     };
     return api;
 }
-async function loadExtensionModule(extensionPath) {
+function isCurrentCacheToken(cacheToken) {
+    return (cacheToken !== undefined &&
+        extensionCacheCwd === cacheToken.cwd &&
+        extensionCacheGeneration === cacheToken.generation);
+}
+async function loadExtensionModule(extensionPath, cacheToken) {
+    if (isCurrentCacheToken(cacheToken)) {
+        const cachedFactory = extensionCache.get(extensionPath);
+        if (cachedFactory) {
+            return cachedFactory;
+        }
+    }
     const jiti = createJiti(import.meta.url, {
         moduleCache: false,
         // In Bun binary: use virtualModules for bundled packages (no filesystem resolution)
@@ -271,7 +308,13 @@ async function loadExtensionModule(extensionPath) {
     });
     const module = await jiti.import(extensionPath, { default: true });
     const factory = module;
-    return typeof factory !== "function" ? undefined : factory;
+    if (typeof factory !== "function") {
+        return undefined;
+    }
+    if (isCurrentCacheToken(cacheToken)) {
+        extensionCache.set(extensionPath, factory);
+    }
+    return factory;
 }
 /**
  * Create an Extension object with empty collections.
@@ -293,10 +336,10 @@ function createExtension(extensionPath, resolvedPath) {
         shortcuts: new Map(),
     };
 }
-async function loadExtension(extensionPath, cwd, eventBus, runtime) {
+async function loadExtension(extensionPath, cwd, eventBus, runtime, cacheToken) {
     const resolvedPath = resolvePath(extensionPath, cwd, { normalizeUnicodeSpaces: true });
     try {
-        const factory = await loadExtensionModule(resolvedPath);
+        const factory = await loadExtensionModule(resolvedPath, cacheToken);
         if (!factory) {
             return { extension: null, error: `Extension does not export a valid factory function: ${extensionPath}` };
         }
@@ -323,14 +366,15 @@ export async function loadExtensionFromFactory(factory, cwd, eventBus, runtime,
 /**
  * Load extensions from paths.
  */
-export async function loadExtensions(paths, cwd, eventBus, runtime) {
+async function loadExtensionsInternal(paths, cwd, eventBus, runtime, useCache = false) {
     const extensions = [];
     const errors = [];
-    const resolvedCwd = resolvePath(cwd);
+    const cacheToken = useCache ? useExtensionCacheCwd(cwd) : undefined;
+    const resolvedCwd = cacheToken?.cwd ?? resolvePath(cwd);
     const resolvedEventBus = eventBus ?? createEventBus();
     const resolvedRuntime = runtime ?? createExtensionRuntime();
     for (const extPath of paths) {
-        const { extension, error } = await loadExtension(extPath, resolvedCwd, resolvedEventBus, resolvedRuntime);
+        const { extension, error } = await loadExtension(extPath, resolvedCwd, resolvedEventBus, resolvedRuntime, cacheToken);
         if (error) {
             errors.push({ path: extPath, error });
             continue;
@@ -345,6 +389,12 @@ export async function loadExtensions(paths, cwd, eventBus, runtime) {
         runtime: resolvedRuntime,
     };
 }
+export async function loadExtensions(paths, cwd, eventBus, runtime) {
+    return loadExtensionsInternal(paths, cwd, eventBus, runtime);
+}
+export async function loadExtensionsCached(paths, cwd, eventBus, runtime) {
+    return loadExtensionsInternal(paths, cwd, eventBus, runtime, true);
+}
 function readPiManifest(packageJsonPath) {
     try {
         const content = fs.readFileSync(packageJsonPath, "utf-8");

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/runner.js

@@ -320,7 +320,7 @@ export class ExtensionRunner {
     getShortcutDiagnostics() {
         return this.shortcutDiagnostics;
     }
-    invalidate(message = "This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().") {
+    invalidate(message = "This extension ctx is stale after session replacement or reload. Do not use a captured sling or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().") {
         if (!this.staleMessage) {
             this.staleMessage = message;
             this.runtime.invalidate(message);

package/node_modules/@earendil-works/pi-coding-agent/dist/core/model-registry.js

@@ -1,7 +1,7 @@
 /**
  * Model registry - manages built-in and custom models, provides API key resolution.
  */
-import { getModels, getProviders, registerApiProvider, resetApiProviders, } from "@earendil-works/pi-ai";
+import { getModels, getProviders, registerApiProvider, resetApiProviders, } from "@earendil-works/pi-ai/compat";
 import { registerOAuthProvider, resetOAuthProviders } from "@earendil-works/pi-ai/oauth";
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
@@ -61,6 +61,12 @@ const ThinkingLevelMapSchema = Type.Object({
     high: Type.Optional(ThinkingLevelMapValueSchema),
     xhigh: Type.Optional(ThinkingLevelMapValueSchema),
 });
+const ChatTemplateKwargScalarSchema = Type.Union([Type.String(), Type.Number(), Type.Boolean(), Type.Null()]);
+const ChatTemplateKwargVariableSchema = Type.Object({
+    $var: Type.Union([Type.Literal("thinking.enabled"), Type.Literal("thinking.effort")]),
+    omitWhenOff: Type.Optional(Type.Boolean()),
+});
+const ChatTemplateKwargSchema = Type.Union([ChatTemplateKwargScalarSchema, ChatTemplateKwargVariableSchema]);
 const OpenAICompletionsCompatSchema = Type.Object({
     supportsStore: Type.Optional(Type.Boolean()),
     supportsDeveloperRole: Type.Optional(Type.Boolean()),
@@ -78,8 +84,12 @@ const OpenAICompletionsCompatSchema = Type.Object({
         Type.Literal("deepseek"),
         Type.Literal("zai"),
         Type.Literal("qwen"),
+        Type.Literal("chat-template"),
         Type.Literal("qwen-chat-template"),
+        Type.Literal("string-thinking"),
+        Type.Literal("ant-ling"),
     ])),
+    chatTemplateKwargs: Type.Optional(Type.Record(Type.String(), ChatTemplateKwargSchema)),
     cacheControlFormat: Type.Optional(Type.Literal("anthropic")),
     openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
     vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema),
@@ -192,6 +202,12 @@ function mergeCompat(baseCompat, overrideCompat) {
             ...overrideCompletions.vercelGatewayRouting,
         };
     }
+    if (baseCompletions?.chatTemplateKwargs || overrideCompletions.chatTemplateKwargs) {
+        mergedCompletions.chatTemplateKwargs = {
+            ...baseCompletions?.chatTemplateKwargs,
+            ...overrideCompletions.chatTemplateKwargs,
+        };
+    }
     return merged;
 }
 /**
@@ -589,7 +605,7 @@ export class ModelRegistry {
      * Get API key for a provider.
      */
     async getApiKeyForProvider(provider) {
-        const apiKey = await this.authStorage.getApiKey(provider, { includeFallback: false });
+        const apiKey = await this.authStorage.getApiKey(provider);
         if (apiKey !== undefined) {
             return apiKey;
         }

package/node_modules/@earendil-works/pi-coding-agent/dist/core/project-trust.js

@@ -1,7 +1,8 @@
+import { CONFIG_DIR_NAME } from "../config.js";
 import { emitProjectTrustEvent } from "./extensions/runner.js";
 import { getProjectTrustOptions, hasTrustRequiringProjectResources, } from "./trust-manager.js";
 function formatProjectTrustPrompt(cwd) {
-    return `Trust project folder?\n${cwd}\n\nThis allows pi to load .pi settings and resources, install missing project packages, and execute project extensions.`;
+    return `Trust project folder?\n${cwd}\n\nThis allows sling to load ${CONFIG_DIR_NAME} settings and resources, install missing project packages, and execute project extensions.`;
 }
 async function selectProjectTrustOption(cwd, ctx) {
     const options = getProjectTrustOptions(cwd, { includeSessionOnly: true });

package/node_modules/@earendil-works/pi-coding-agent/dist/core/provider-display-names.js

@@ -26,7 +26,7 @@ export const BUILT_IN_PROVIDER_DISPLAY_NAMES = {
     together: "Together AI",
     "vercel-ai-gateway": "Vercel AI Gateway",
     xai: "xAI",
-    zai: "ZAI",
+    zai: "ZAI Coding Plan (Global)",
     "zai-coding-cn": "ZAI Coding Plan (China)",
     xiaomi: "Xiaomi MiMo",
     "xiaomi-token-plan-cn": "Xiaomi MiMo Token Plan (China)",

package/node_modules/@earendil-works/pi-coding-agent/dist/core/resolve-config-value.js

@@ -129,11 +129,13 @@ export function resolveConfigValue(config, env) {
 }
 function executeWithConfiguredShell(command) {
     try {
-        const { shell, args } = getShellConfig();
-        const result = spawnSync(shell, [...args, command], {
+        const { shell, args, commandTransport } = getShellConfig();
+        const commandFromStdin = commandTransport === "stdin";
+        const result = spawnSync(shell, commandFromStdin ? args : [...args, command], {
             encoding: "utf-8",
+            input: commandFromStdin ? command : undefined,
             timeout: 10000,
-            stdio: ["ignore", "pipe", "ignore"],
+            stdio: [commandFromStdin ? "pipe" : "ignore", "pipe", "ignore"],
             shell: false,
             windowsHide: true,
         });

package/node_modules/@earendil-works/pi-coding-agent/dist/core/resource-loader.js

@@ -5,7 +5,7 @@ import { CONFIG_DIR_NAME } from "../config.js";
 import { loadThemeFromPath } from "../modes/interactive/theme/theme.js";
 import { canonicalizePath, isLocalPath, resolvePath } from "../utils/paths.js";
 import { createEventBus } from "./event-bus.js";
-import { createExtensionRuntime, loadExtensionFromFactory, loadExtensions } from "./extensions/loader.js";
+import { clearExtensionCache, createExtensionRuntime, loadExtensionFromFactory, loadExtensionsCached, } from "./extensions/loader.js";
 import { DefaultPackageManager } from "./package-manager.js";
 import { loadPromptTemplates } from "./prompt-templates.js";
 import { SettingsManager } from "./settings-manager.js";
@@ -114,6 +114,7 @@ export class DefaultResourceLoader {
     extensionThemeSourceInfos;
     lastPromptPaths;
     lastThemePaths;
+    loaded;
     constructor(options) {
         this.cwd = resolvePath(options.cwd);
         this.agentDir = resolvePath(options.agentDir);
@@ -158,6 +159,7 @@ export class DefaultResourceLoader {
         this.extensionThemeSourceInfos = new Map();
         this.lastPromptPaths = [];
         this.lastThemePaths = [];
+        this.loaded = false;
     }
     getExtensions() {
         return this.extensionsResult;
@@ -214,6 +216,9 @@ export class DefaultResourceLoader {
         return this.loadCurrentExtensionSet({ includeInlineFactories: true });
     }
     async reload(options) {
+        if (this.loaded) {
+            clearExtensionCache();
+        }
         let preTrustExtensions;
         if (options?.resolveProjectTrust) {
             preTrustExtensions = await this.loadProjectTrustExtensions();
@@ -335,6 +340,7 @@ export class DefaultResourceLoader {
         this.appendSystemPrompt = this.appendSystemPromptOverride
             ? this.appendSystemPromptOverride(baseAppend)
             : baseAppend;
+        this.loaded = true;
     }
     async loadCurrentExtensionSet(options) {
         const resolvedPaths = await this.packageManager.resolve();
@@ -346,7 +352,7 @@ export class DefaultResourceLoader {
         const extensionPaths = this.noExtensions
             ? cliEnabledExtensions
             : this.mergePaths(cliEnabledExtensions, enabledExtensions);
-        const extensionsResult = await loadExtensions(extensionPaths, this.cwd, this.eventBus);
+        const extensionsResult = await loadExtensionsCached(extensionPaths, this.cwd, this.eventBus);
         if (!options.includeInlineFactories) {
             return extensionsResult;
         }
@@ -360,7 +366,7 @@ export class DefaultResourceLoader {
     }
     async loadFinalExtensionSet(extensionPaths, preTrustExtensions) {
         if (!preTrustExtensions) {
-            const extensionsResult = await loadExtensions(extensionPaths, this.cwd, this.eventBus);
+            const extensionsResult = await loadExtensionsCached(extensionPaths, this.cwd, this.eventBus);
             const inlineExtensions = await this.loadExtensionFactories(extensionsResult.runtime);
             extensionsResult.extensions.push(...inlineExtensions.extensions);
             extensionsResult.errors.push(...inlineExtensions.errors);
@@ -375,7 +381,7 @@ export class DefaultResourceLoader {
             const resolvedPath = this.resolveExtensionLoadPath(path);
             return !preloadedByPath.has(resolvedPath) && !failedPreloadPaths.has(resolvedPath);
         });
-        const remainingExtensions = await loadExtensions(remainingPaths, this.cwd, this.eventBus, preTrustExtensions.runtime);
+        const remainingExtensions = await loadExtensionsCached(remainingPaths, this.cwd, this.eventBus, preTrustExtensions.runtime);
         const loadedByPath = new Map(preloadedByPath);
         for (const extension of remainingExtensions.extensions) {
             loadedByPath.set(extension.resolvedPath, extension);

package/node_modules/@earendil-works/pi-coding-agent/dist/core/sdk.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import { Agent } from "@earendil-works/pi-agent-core";
-import { clampThinkingLevel, streamSimple } from "@earendil-works/pi-ai";
+import { clampThinkingLevel, streamSimple } from "@earendil-works/pi-ai/compat";
 import { getAgentDir } from "../config.js";
 import { resolvePath } from "../utils/paths.js";
 import { AgentSession } from "./agent-session.js";

package/node_modules/@earendil-works/pi-coding-agent/dist/core/session-manager.js

@@ -145,9 +145,10 @@ export function buildSessionContext(entries, leafId, byId) {
     const path = [];
     let current = leaf;
     while (current) {
-        path.unshift(current);
+        path.push(current);
         current = current.parentId ? byId.get(current.parentId) : undefined;
     }
+    path.reverse();
     // Extract settings and find compaction
     let thinkingLevel = "off";
     let model = null;
@@ -856,9 +857,10 @@ export class SessionManager {
         const startId = fromId ?? this.leafId;
         let current = startId ? this.byId.get(startId) : undefined;
         while (current) {
-            path.unshift(current);
+            path.push(current);
             current = current.parentId ? this.byId.get(current.parentId) : undefined;
         }
+        path.reverse();
         return path;
     }
     /**

package/node_modules/@earendil-works/pi-coding-agent/dist/core/settings-manager.js

@@ -163,11 +163,11 @@ export class SettingsManager {
         return new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted);
     }
     /** Create an in-memory SettingsManager (no file I/O) */
-    static inMemory(settings = {}) {
+    static inMemory(settings = {}, options = {}) {
         const storage = new InMemorySettingsStorage();
         const initialSettings = SettingsManager.migrateSettings(structuredClone(settings));
         storage.withLock("global", () => JSON.stringify(initialSettings, null, 2));
-        return SettingsManager.fromStorage(storage);
+        return SettingsManager.fromStorage(storage, options);
     }
     static loadFromStorage(storage, scope, projectTrusted = true) {
         if (scope === "project" && !projectTrusted) {
@@ -475,8 +475,15 @@ export class SettingsManager {
         this.markModified("followUpMode");
         this.save();
     }
+    getThemeSetting() {
+        const value = this.settings.theme;
+        if (typeof value === "string")
+            return value;
+        return undefined;
+    }
     getTheme() {
-        return this.settings.theme;
+        const theme = this.getThemeSetting();
+        return theme?.includes("/") ? undefined : theme;
     }
     setTheme(theme) {
         this.globalSettings.theme = theme;

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/bash.js

@@ -25,7 +25,7 @@ const bashSchema = Type.Object({
 export function createLocalBashOperations(options) {
     return {
         exec: async (command, cwd, { onData, signal, timeout, env }) => {
-            const { shell, args } = getShellConfig(options?.shellPath);
+            const shellConfig = getShellConfig(options?.shellPath);
             try {
                 await fsAccess(cwd, constants.F_OK);
             }
@@ -35,13 +35,18 @@ export function createLocalBashOperations(options) {
             if (signal?.aborted) {
                 throw new Error("aborted");
             }
-            const child = spawn(shell, [...args, command], {
+            const commandFromStdin = shellConfig.commandTransport === "stdin";
+            const child = spawn(shellConfig.shell, commandFromStdin ? shellConfig.args : [...shellConfig.args, command], {
                 cwd,
                 detached: process.platform !== "win32",
                 env: env ?? getShellEnv(),
-                stdio: ["ignore", "pipe", "pipe"],
+                stdio: [commandFromStdin ? "pipe" : "ignore", "pipe", "pipe"],
                 windowsHide: true,
             });
+            if (commandFromStdin) {
+                child.stdin?.on("error", () => { });
+                child.stdin?.end(command);
+            }
             if (child.pid)
                 trackDetachedChildPid(child.pid);
             let timedOut = false;

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/edit-diff.js

@@ -1,6 +1,5 @@
 /**
- * Shared diff computation utilities for the edit tool.
- * Used by both edit.ts (for execution) and tool-execution.ts (for preview rendering).
+ * Shared diff computation utilities for the edit and similar tools.
  */
 import * as Diff from "diff";
 import { constants } from "fs";
@@ -48,6 +47,90 @@ export function normalizeForFuzzyMatch(text) {
         // U+205F medium math space, U+3000 ideographic space
         .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " "));
 }
+function splitLinesWithEndings(content) {
+    return content.match(/[^\n]*\n|[^\n]+/g) ?? [];
+}
+function getLineSpans(content) {
+    let offset = 0;
+    return splitLinesWithEndings(content).map((line) => {
+        const span = { start: offset, end: offset + line.length };
+        offset = span.end;
+        return span;
+    });
+}
+function getReplacementLineRange(lines, replacement) {
+    const replacementStart = replacement.matchIndex;
+    const replacementEnd = replacement.matchIndex + replacement.matchLength;
+    let startLine = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (replacementStart >= line.start && replacementStart < line.end) {
+            startLine = i;
+            break;
+        }
+    }
+    if (startLine === -1) {
+        throw new Error("Replacement range is outside the base content.");
+    }
+    let endLine = startLine;
+    while (endLine < lines.length && lines[endLine].end < replacementEnd) {
+        endLine++;
+    }
+    if (endLine >= lines.length) {
+        throw new Error("Replacement range is outside the base content.");
+    }
+    return { startLine, endLine: endLine + 1 };
+}
+function applyReplacements(content, replacements, offset = 0) {
+    let result = content;
+    for (let i = replacements.length - 1; i >= 0; i--) {
+        const replacement = replacements[i];
+        const matchIndex = replacement.matchIndex - offset;
+        result =
+            result.substring(0, matchIndex) + replacement.newText + result.substring(matchIndex + replacement.matchLength);
+    }
+    return result;
+}
+/**
+ * Apply replacements matched against `baseContent` to `originalContent` while
+ * preserving unchanged line blocks from the original.
+ *
+ * This is useful when `baseContent` is a normalized view of the original. Each
+ * replacement is widened to the lines it actually touches, those touched lines
+ * are rewritten from the normalized base, and all other lines are copied back
+ * from `originalContent`. The actual replacement ranges drive preservation so
+ * duplicate normalized lines cannot be aligned to the wrong occurrence.
+ */
+export function applyReplacementsPreservingUnchangedLines(originalContent, baseContent, replacements) {
+    const originalLines = splitLinesWithEndings(originalContent);
+    const baseLines = getLineSpans(baseContent);
+    if (originalLines.length !== baseLines.length) {
+        throw new Error("Cannot preserve unchanged lines because the base content has a different line count.");
+    }
+    const groups = [];
+    const sortedReplacements = [...replacements].sort((a, b) => a.matchIndex - b.matchIndex);
+    for (const replacement of sortedReplacements) {
+        const range = getReplacementLineRange(baseLines, replacement);
+        const current = groups[groups.length - 1];
+        if (current && range.startLine < current.endLine) {
+            current.endLine = Math.max(current.endLine, range.endLine);
+            current.replacements.push(replacement);
+            continue;
+        }
+        groups.push({ ...range, replacements: [replacement] });
+    }
+    let originalLineIndex = 0;
+    let result = "";
+    for (const group of groups) {
+        result += originalLines.slice(originalLineIndex, group.startLine).join("");
+        const groupStartOffset = baseLines[group.startLine].start;
+        const groupEndOffset = baseLines[group.endLine - 1].end;
+        result += applyReplacements(baseContent.slice(groupStartOffset, groupEndOffset), group.replacements, groupStartOffset);
+        originalLineIndex = group.endLine;
+    }
+    result += originalLines.slice(originalLineIndex).join("");
+    return result;
+}
 /**
  * Find oldText in content, trying exact match first, then fuzzy match.
  * When fuzzy matching is used, the returned contentForReplacement is the
@@ -79,9 +162,9 @@ export function fuzzyFindText(content, oldText) {
             contentForReplacement: content,
         };
     }
-    // When fuzzy matching, we work in the normalized space for replacement.
-    // This means the output will have normalized whitespace/quotes/dashes,
-    // which is acceptable since we're fixing minor formatting differences anyway.
+    // When fuzzy matching, return offsets in normalized space. Callers can use
+    // the normalized content to compute replacements, then decide how much of
+    // that normalized output should be written back.
     return {
         found: true,
         index: fuzzyIndex,
@@ -128,8 +211,9 @@ function getNoChangeError(path, totalEdits) {
  *
  * All edits are matched against the same original content. Replacements are
  * then applied in reverse order so offsets remain stable. If any edit needs
- * fuzzy matching, the operation runs in fuzzy-normalized content space to
- * preserve current single-edit behavior.
+ * fuzzy matching, the operation runs in fuzzy-normalized content space and then
+ * overlays those line-level changes onto the original content so unchanged line
+ * blocks keep their original bytes.
  */
 export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
     const normalizedEdits = edits.map((edit) => ({
@@ -142,17 +226,16 @@ export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
         }
     }
     const initialMatches = normalizedEdits.map((edit) => fuzzyFindText(normalizedContent, edit.oldText));
-    const baseContent = initialMatches.some((match) => match.usedFuzzyMatch)
-        ? normalizeForFuzzyMatch(normalizedContent)
-        : normalizedContent;
+    const usedFuzzyMatch = initialMatches.some((match) => match.usedFuzzyMatch);
+    const replacementBaseContent = usedFuzzyMatch ? normalizeForFuzzyMatch(normalizedContent) : normalizedContent;
     const matchedEdits = [];
     for (let i = 0; i < normalizedEdits.length; i++) {
         const edit = normalizedEdits[i];
-        const matchResult = fuzzyFindText(baseContent, edit.oldText);
+        const matchResult = fuzzyFindText(replacementBaseContent, edit.oldText);
         if (!matchResult.found) {
             throw getNotFoundError(path, i, normalizedEdits.length);
         }
-        const occurrences = countOccurrences(baseContent, edit.oldText);
+        const occurrences = countOccurrences(replacementBaseContent, edit.oldText);
         if (occurrences > 1) {
             throw getDuplicateError(path, i, normalizedEdits.length, occurrences);
         }
@@ -171,14 +254,10 @@ export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
             throw new Error(`edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${path}. Merge them into one edit or target disjoint regions.`);
         }
     }
-    let newContent = baseContent;
-    for (let i = matchedEdits.length - 1; i >= 0; i--) {
-        const edit = matchedEdits[i];
-        newContent =
-            newContent.substring(0, edit.matchIndex) +
-                edit.newText +
-                newContent.substring(edit.matchIndex + edit.matchLength);
-    }
+    const baseContent = normalizedContent;
+    const newContent = usedFuzzyMatch
+        ? applyReplacementsPreservingUnchangedLines(normalizedContent, replacementBaseContent, matchedEdits)
+        : applyReplacements(replacementBaseContent, matchedEdits);
     if (baseContent === newContent) {
         throw getNoChangeError(path, normalizedEdits.length);
     }

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/find.js

@@ -163,17 +163,25 @@ export function createFindToolDefinition(cwd, options) {
                             settle(() => reject(new Error("fd is not available and could not be downloaded")));
                             return;
                         }
-                        // Build fd arguments. --no-require-git makes fd apply hierarchical .gitignore
-                        // semantics whether or not the search path is inside a git repository, without
-                        // leaking sibling-directory rules the way --ignore-file (a global source) would.
-                        const args = [
-                            "--glob",
-                            "--color=never",
-                            "--hidden",
-                            "--no-require-git",
-                            "--max-results",
-                            String(effectiveLimit),
-                        ];
+                        const args = ["--glob", "--color=never", "--hidden"];
+                        // fd normally ignores .gitignore outside git repos, so keep --no-require-git
+                        // there. Inside repos, use fd's default git-aware behavior so parent
+                        // .gitignore rules stop at nested repo boundaries:
+                        // https://github.com/earendil-works/pi/issues/5960
+                        let insideGitRepo = false;
+                        for (let current = searchPath;;) {
+                            if (await pathExists(path.join(current, ".git"))) {
+                                insideGitRepo = true;
+                                break;
+                            }
+                            const parent = path.dirname(current);
+                            if (parent === current)
+                                break;
+                            current = parent;
+                        }
+                        if (!insideGitRepo)
+                            args.push("--no-require-git");
+                        args.push("--max-results", String(effectiveLimit));
                         // fd --glob matches against the basename unless --full-path is set; in --full-path
                         // mode it matches against the absolute candidate path, so a path-containing
                         // pattern like 'src/**/*.spec.ts' needs a leading '**/' to match anything.