@oh-my-pi/pi-coding-agent 14.6.2 → 14.6.4

package/src/config/settings.ts

@@ -568,6 +568,48 @@ export class Settings {
 			}
 		}
 
+		// Map legacy `memories.enabled` boolean to the explicit `memory.backend`
+		// enum if the latter hasn't been set yet. Idempotent: subsequent
+		// migrations are no-ops once memory.backend is materialised.
+		const memoryBackendObj = raw.memory as Record<string, unknown> | undefined;
+		const memoryBackendSet = memoryBackendObj && typeof memoryBackendObj.backend === "string";
+		const memoriesObj = raw.memories as Record<string, unknown> | undefined;
+		if (!memoryBackendSet && memoriesObj && typeof memoriesObj.enabled === "boolean") {
+			const next = memoriesObj.enabled ? "local" : "off";
+			const memoryRoot = (memoryBackendObj ?? {}) as Record<string, unknown>;
+			memoryRoot.backend = next;
+			raw.memory = memoryRoot;
+		}
+
+		// hindsight: dynamicBankId/agentName -> scoping enum + bankId
+		// - dynamicBankId=true  → scoping="per-project" (closest semantic match;
+		//   the legacy `agent::project::channel::user` tuple was per-project in
+		//   practice — the channel/user env vars were rarely set).
+		// - hindsight.agentName was only used as the agent slot in the legacy
+		//   dynamic tuple; if the user customised it we surface it as the new
+		//   bankId base when no explicit bankId is set.
+		const hindsightObj = raw.hindsight as Record<string, unknown> | undefined;
+		if (hindsightObj) {
+			if ("dynamicBankId" in hindsightObj) {
+				if (!("scoping" in hindsightObj) && hindsightObj.dynamicBankId === true) {
+					hindsightObj.scoping = "per-project";
+				}
+				delete hindsightObj.dynamicBankId;
+			}
+			if ("agentName" in hindsightObj) {
+				const agentName = hindsightObj.agentName;
+				if (
+					!("bankId" in hindsightObj) &&
+					typeof agentName === "string" &&
+					agentName.trim().length > 0 &&
+					agentName !== "omp"
+				) {
+					hindsightObj.bankId = agentName;
+				}
+				delete hindsightObj.agentName;
+			}
+		}
+
 		return raw;
 	}
 

package/src/discovery/helpers.ts

@@ -3,7 +3,14 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { FileType, glob } from "@oh-my-pi/pi-natives";
-import { CONFIG_DIR_NAME, getConfigDirName, getProjectDir, parseFrontmatter, tryParseJson } from "@oh-my-pi/pi-utils";
+import {
+	CONFIG_DIR_NAME,
+	getConfigDirName,
+	getPluginsDir,
+	getProjectDir,
+	parseFrontmatter,
+	tryParseJson,
+} from "@oh-my-pi/pi-utils";
 import type { ExtensionModule } from "../capability/extension-module";
 import { invalidate as invalidateFsCache, readDirEntries, readFile } from "../capability/fs";
 import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../capability/rule";
@@ -804,8 +811,9 @@ export async function listClaudePluginRoots(
 
 	// ── OMP installed plugins registry ───────────────────────────────────────
 	// OMP registry is authoritative: its entries replace Claude's entries for the same plugin ID.
-	// Path derived from `home` (not os.homedir()) so test isolation works when home is overridden.
-	const ompRegistryPath = path.join(home, getConfigDirName(), "plugins", "installed_plugins.json");
+	// getPluginsDir() resolves to the same path the marketplace writer uses
+	// (XDG-aware via the dir resolver), so reads and writes always agree.
+	const ompRegistryPath = path.join(getPluginsDir(), "installed_plugins.json");
 	const ompContent = await readFile(ompRegistryPath);
 	if (ompContent) {
 		const ompRegistry = parseClaudePluginsRegistry(ompContent);
@@ -928,9 +936,8 @@ export function clearClaudePluginRootsCache(): void {
  * installing/uninstalling/enabling/disabling plugins.
  */
 export function clearPluginRootsAndCaches(extraPaths?: readonly string[]): void {
-	const home = os.homedir();
-	invalidateFsCache(path.join(home, ".claude", "plugins", "installed_plugins.json"));
-	invalidateFsCache(path.join(home, getConfigDirName(), "plugins", "installed_plugins.json"));
+	invalidateFsCache(path.join(os.homedir(), ".claude", "plugins", "installed_plugins.json"));
+	invalidateFsCache(path.join(getPluginsDir(), "installed_plugins.json"));
 	for (const p of extraPaths ?? []) invalidateFsCache(p);
 	clearClaudePluginRootsCache();
 }

package/src/edit/index.ts

@@ -16,7 +16,7 @@ import type { ToolSession } from "../tools";
 import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
-import { resolveLarkLidPlaceholders } from "./line-hash";
+import { resolveHashlineGrammarPlaceholders } from "./line-hash";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import {
@@ -35,8 +35,8 @@ export * from "./apply-patch";
 export * from "./diff";
 export * from "./line-hash";
 
-// Resolve the `$HASHFMT$` placeholder in the hashline Lark grammar.
-const hashlineGrammar = resolveLarkLidPlaceholders(hashlineGrammarTemplate);
+// Resolve the `$HFMT$` and `$HSEP$` placeholders in the hashline Lark grammar.
+const hashlineGrammar = resolveHashlineGrammarPlaceholders(hashlineGrammarTemplate);
 
 export * from "./modes/apply-patch";
 export * from "./modes/hashline";

package/src/edit/line-hash.ts

@@ -15,7 +15,7 @@
  * Order is stable forever — changing it would invalidate every saved
  * `LINE+ID` reference in transcripts and prompts.
  */
-export const HASHLINE_BIGRAMS = [
+export const HL_BIGRAMS = [
 	"aa",
 	"ab",
 	"ac",
@@ -665,7 +665,7 @@ export const HASHLINE_BIGRAMS = [
 	"zz",
 ] as const;
 
-export const HASHLINE_BIGRAMS_COUNT = HASHLINE_BIGRAMS.length;
+export const HL_BIGRAMS_COUNT = HL_BIGRAMS.length;
 
 /**
  * Decoration prefix that may precede a `LINE+HASH` anchor in tool output:
@@ -675,7 +675,7 @@ export const HASHLINE_BIGRAMS_COUNT = HASHLINE_BIGRAMS.length;
  * regex stays liberal because anchor-ref parsers accept whatever the model
  * echoes back.
  */
-export const HASHLINE_ANCHOR_DECORATION_RE_SRC = `\\s*[>+\\-*]*\\s*`;
+export const HL_ANCHOR_DECORATION_RE_RAW = `\\s*[>+\\-*]*\\s*`;
 
 /**
  * Capture-group regex source for a decorated `LINE+HASH` anchor. Group 1
@@ -683,62 +683,110 @@ export const HASHLINE_ANCHOR_DECORATION_RE_SRC = `\\s*[>+\\-*]*\\s*`;
  * source is intentionally unanchored — anchoring with `^` (or composing into a
  * larger pattern) is the caller's responsibility.
  */
-export const HASHLINE_ANCHOR_RE_SRC = `${HASHLINE_ANCHOR_DECORATION_RE_SRC}(\\d+)([a-z]{2})`;
+export const HL_ANCHOR_RE_RAW = `${HL_ANCHOR_DECORATION_RE_RAW}(\\d+)([a-z]{2})`;
 
 /**
  * Bare `LINE+HASH` Lid (no decorations, no captures, no anchors). Use for
  * embedding inside larger patterns where the line+hash unit appears as a
  * literal (e.g. range bounds, alternation arms, op-line heuristics).
  */
-export const HASHLINE_LID_RE_SRC = `[1-9]\\d*[a-z]{2}`;
+export const HL_HASH_RE_RAW = `[1-9]\\d*[a-z]{2}`;
 
 /**
- * Capture-group form of {@link HASHLINE_LID_RE_SRC}: group 1 captures the
+ * Capture-group form of {@link HL_HASH_RE_RAW}: group 1 captures the
  * line number, group 2 captures the hash.
  */
-export const HASHLINE_LID_CAPTURE_RE_SRC = `([1-9]\\d*)([a-z]{2})`;
+export const HL_HASH_CAPTURE_RE_RAW = `([1-9]\\d*)([a-z]{2})`;
 
 /** Width of a hash in display characters. */
-export const HASHLINE_HASH_WIDTH = 2;
+export const HL_HASH_WIDTH = 2;
 
 /**
  * Representative hash suffixes for use in user-facing error messages and
  * prompt examples.
  */
-export const HASHLINE_HASH_EXAMPLES = ["sr", "ab", "th"] as const;
+export const HL_HASH_EXAMPLES = ["sr", "ab", "th"] as const;
 
 /**
  * Format a comma-separated list of example anchors with an optional line-number
  * prefix, quoted for inclusion in error messages: `"160sr", "160ab", "160th"`.
  */
 export function describeAnchorExamples(linePrefix = ""): string {
-	return HASHLINE_HASH_EXAMPLES.map(e => `"${linePrefix}${e}"`).join(", ");
+	return HL_HASH_EXAMPLES.map(e => `"${linePrefix}${e}"`).join(", ");
 }
 
 /**
- * Sentinel token that the hashline Lark grammar uses for the hash
- * regex source. Replaced at module-load time by {@link resolveLarkLidPlaceholders}
- * so the grammar is re-derived from a single source of truth alongside its
- * TypeScript consumers. Update the placeholder name here and in the grammar together.
+ * Substitute every grammar placeholder with the value derived from its
+ * TypeScript counterpart. Grammars that don't reference these placeholders
+ * pass through unchanged.
  */
-export const LARK_LID_HASH_PLACEHOLDER = "$HASHFMT$";
+export function resolveHashlineGrammarPlaceholders(grammar: string): string {
+	return grammar.replaceAll("$HFMT$", "[a-z]{2}").replaceAll("$HSEP$", JSON.stringify(HL_EDIT_SEP));
+}
+
+/** @deprecated Use {@link resolveHashlineGrammarPlaceholders}. */
+export const resolveLarkLidPlaceholders = resolveHashlineGrammarPlaceholders;
+
+const regexEscape = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 /**
- * Substitute the LID hash placeholder in a Lark grammar text with the
- * `[a-z]{2}` hash regex source. Grammars that don't reference Lids pass
- * through unchanged.
+ * Single source of truth for the hashline edit payload separator. This is the
+ * configured separator that starts inserted/replacement payload lines in
+ * hashline edit input (`<separator>TEXT`) and separates inline modify ops from
+ * their appended/prepended text.
+ *
+ * Override at runtime with the `PI_HL_SEP` env var (e.g.
+ * `PI_HL_SEP=">"`, `PI_HL_SEP="\\"`). The value is read once at module load;
+ * the edit grammar, prompt helper, and edit parser derive from it.
+ *
+ * Default is `~`, chosen empirically. Benchmark across 8 candidate separators
+ * x 3 models (glm-4.7:nitro, gpt-5.4-nano, claude-sonnet-4-6), 24-48 runs per
+ * cell, hashline variant, 12 sampled tasks per run:
+ *
+ *   sep | task ✓ | edit ✓ | patch fail      | tok/run
+ *   ----|--------|--------|-----------------|--------
+ *    +  | 70.8%  | 78.0%  | 27/125 (21.6%)  | 32,127
+ *    ÷  | 70.7%  | 90.6%  | 22/211 (10.4%)  | 31,666
+ *    ~  | 69.4%  | 94.9%  |  6/107 ( 5.6%)  | 30,529   <-- default
+ *    >  | 69.2%  | 91.5%  | 21/219 ( 9.6%)  | 30,777
+ *    :  | 66.7%  | 86.4%  | 20/126 (15.9%)  | 33,900
+ *    |  | 65.9%  | 86.9%  | 20/127 (15.7%)  | 34,589
+ *    \  | 65.5%  | 89.8%  | 16/124 (12.9%)  | 36,010
+ *    %  | 63.9%  | 92.8%  | 11/125 ( 8.8%)  | 36,530
+ *
+ * `~` wins because:
+ *   - highest edit-tool success rate (94.9%) of any tested separator
+ *   - lowest patch-failure rate (5.6%) — model rarely emits a malformed payload
+ *   - cheapest in tokens alongside `>` (no retry overhead from format collisions)
+ *   - no line-leading role in any mainstream language, markdown, diff, regex,
+ *     or shell, so payload lines are unambiguous to both the parser and models
+ *   - task-success is statistically tied with `>` and `÷` (within run-to-run
+ *     noise), so the edit-reliability win is free
+ *
+ * `+` and `÷` lead on raw task-success but at the cost of ~2-4x more patch
+ * failures (the model retries until it lands a valid edit). `:`, `|`, `\`
+ * collide with line-leading syntax (label/object-key, body separator, escape)
+ * and degrade both edit reliability and intent-match.
  */
-export function resolveLarkLidPlaceholders(grammar: string): string {
-	return grammar.replaceAll(LARK_LID_HASH_PLACEHOLDER, "[a-z]{2}");
-}
+export const HL_EDIT_SEP = (() => {
+	const sep = process.env.PI_HL_SEP?.trim();
+	return sep?.length === 1 ? sep : "~";
+})();
+
+/** Regex-escaped form of {@link HL_EDIT_SEP}, safe for regexes. */
+export const HL_EDIT_SEP_RE_RAW = regexEscape(HL_EDIT_SEP);
+
+/** Stable separator for read/search/hashline display output. Intentionally not configurable. */
+export const HL_BODY_SEP = "|";
 
-export const HASHLINE_CONTENT_SEPARATOR = "|";
+/** Regex-escaped form of {@link HL_BODY_SEP}, safe for embedding inside a regex. */
+export const HL_BODY_SEP_RE_RAW = regexEscape(HL_BODY_SEP);
 
 const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
 
 /**
  * Compute a 2-character hash of a single line via xxHash32 mod 647 over
- * {@link HASHLINE_BIGRAMS}. Lines with no letter or digit (e.g. bare `}`,
+ * {@link HL_BIGRAMS}. Lines with no letter or digit (e.g. bare `}`,
  * bare `{`) mix the line number into the seed so adjacent identical
  * brace-only lines get distinct hashes; lines with significant content stay
  * line-number-independent so a line is identifiable across small shifts.
@@ -748,7 +796,7 @@ const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
 export function computeLineHash(idx: number, line: string): string {
 	line = line.replace(/\r/g, "").trimEnd();
 	const seed = RE_SIGNIFICANT.test(line) ? 0 : idx;
-	return HASHLINE_BIGRAMS[Bun.hash.xxHash32(line, seed) % HASHLINE_BIGRAMS_COUNT];
+	return HL_BIGRAMS[Bun.hash.xxHash32(line, seed) % HL_BIGRAMS_COUNT];
 }
 
 /**
@@ -765,7 +813,7 @@ export function formatLineHash(line: number, lines: string): string {
  * Returns `LINE+ID|TEXT` (e.g., `42sr|function hi() {`, `3ab|}`).
  */
 export function formatHashLine(lineNumber: number, line: string): string {
-	return `${lineNumber}${computeLineHash(lineNumber, line)}${HASHLINE_CONTENT_SEPARATOR}${line}`;
+	return `${lineNumber}${computeLineHash(lineNumber, line)}${HL_BODY_SEP}${line}`;
 }
 
 /**

package/src/edit/modes/hashline.lark

@@ -1,4 +1,5 @@
 %import common.LF
+%import common.WS_INLINE
 
 start: section+
 
@@ -6,21 +7,27 @@ section: file_header line_op*
 
 file_header: "@" path LF
 
-line_op: insert_before_op payload+
+line_op: inline_before_op payload*
+       | inline_after_op payload*
+       | insert_before_op payload+
        | insert_after_op payload+
        | replace_op payload*
        | delete_op
        | blank
 
+inline_before_op: "<" LID $HSEP$ line_text? LF
+inline_after_op: "+" LID $HSEP$ line_text? LF
 insert_before_op: "<" insert_target LF
 insert_after_op: "+" insert_target LF
 replace_op: "=" range LF
 delete_op: "-" range LF
-payload: "|" /[^\r\n]*/ LF
+payload: $HSEP$ line_text? LF
+
+line_text: /[^\r\n]+/
 
 insert_target: LID | "EOF" | "BOF"
 range: LID (".." LID)?
 
 path: /(?:[^\s\r\n]+|"[^"\r\n]+"|'[^'\r\n]+')/
-LID: /[1-9][0-9]*$HASHFMT$/
+LID: /[1-9][0-9]*$HFMT$/
 blank: LF