osdy-pi 1.11.8 → 1.11.10

package/README.md

@@ -63,7 +63,7 @@ Run **`/osdyConfig`** in interactive Pi to open the Osdy Control Center. The ten
 - TODO shows configured selection, current eligibility, and actually loaded SDK registration separately. Opt-in/out requires an idle session and a Cancel-first inline confirmation naming the target, owned Gentle filter effects, and reload. Successful selection closes/disposes the panel and releases its editor hold before reloading once; restart Pi if reload fails. Rejections stay in the panel. No installs or task-history changes occur; legacy `/osdy-pi todo on|off|status` remains available.
 - Agents shows concise **Joker / Gentle** choices without activating anything. With detail focus, visible lowercase-only **j Joker / g Gentle** letters open the existing confirmation directly; only available, unambiguous rows get shortcuts. **↑/↓ + Enter** remains the fallback. Profile and Agent selections survive category navigation; unavailable choices fall back to the current row. Letters never bypass category focus, confirmation, path input, loading, querying, or saving. Selection is idle-only and Cancel-first confirmed, naming the real target, possible Joker installation, owned agent filters, and preserved unrelated resources. Normal personal Pi only: `pi:dev` and isolated/override sessions are blocked, never redirected to personal settings. Success closes/disposes the panel and releases its editor hold before reloading once; restart Pi if reload fails. Legacy `/osdy-pi agents setup|on|off|status` is unchanged.
 - Theme lists Pi's available themes and marks the current theme. Explicit **Page x/N** pages contain at most **8 themes**, fewer in short viewports or with expanded help. **Page Up/Down** changes pages, **Home/End** reaches the first/last theme, and arrows cross page boundaries. Selection survives category navigation and resizing; resizing adjusts the page around the selected theme. A successful selection applies live and saves globally in the active Pi agent directory; project settings can override it at startup. Failures appear in the modal.
-- Header offers **osdy-theme / neon**; Mascot offers **current / Bts**; Editor offers **auto / extended / simple**, with the current preference marked. Editor also shows the effective mode: small terminals stay simple/native even with extended selected.
+- Header offers **osdy-theme / neon**; Mascot offers **current / Bts / Osdy-Halloween**; Editor offers **auto / extended / simple**, with the current preference marked. Editor also shows the effective mode: small terminals stay simple/native even with extended selected.
 - Preferences save immediately through the same runtime and global Osdy settings store as `/osdy-pi` commands (`<agent-dir>/extensions/osdy-pi/settings.json`). Header/Mascot apply live without closing the panel. Editor replacement waits until all overlays close; if another overlay remains, the next existing responsive watcher tick applies the latest choice. The effective mode reports the actually mounted editor while queued. Opening a category only reads values; while Osdy is disabled, choices save for later without enabling it.
 - A selection shows **Saving** until persistence finishes and **Saved globally** only on success. Failed saves retain the live preference but report **could not be saved**; select again to retry. Application errors report **Not saved**, without claiming the runtime change succeeded. Duplicate selections are ignored while saving.
 - **Git** shows the current branch (or detached HEAD), changed-entry count/clean status, and the current widget position as a read-only session detail. Working-tree enablement applies and saves through the same owner as `/osdy-pi working-tree`; Git inspection never writes Git. `/osdy-pi diff` and position commands are unchanged.
@@ -300,7 +300,7 @@ Before rename or removal, close this Pi process when it uses the target and **ma
 | Area | Included behavior |
 | --- | --- |
 | Themes | 23 built-in themes, including Osdy, Kanagawa, Dracula, Gruvbox, Nord, Rosé Pine, Daniela Cute, Halloween, Halloween Killer, Catppuccin, Matrix, Lucent Orange, and three Spider-Man-inspired palettes |
-| Header and mascot | Independently selectable `osdy-theme`/`neon` headers and `current`/`bts` mascots |
+| Header and mascot | Independently selectable `osdy-theme`/`neon` headers and `current`/`bts`/`osdy-halloween` mascots |
 | Messages | Native colored user cards without emojis and plain assistant Markdown with a separate assistant `🦝` row |
 | Input | Responsive auto editor by default, with selectable simple Pi-native or extended framed modes |
 | Status | Six activity labels with compact per-state glyphs and a shared theme-color pulse, responsive footer metrics, dynamic extension statuses, and Codex subscription quota with low-capacity emphasis |
@@ -366,10 +366,12 @@ Header and mascot choices are independent:
 | Element | Choices | Command |
 | --- | --- | --- |
 | Header | `osdy-theme` (default), `neon` | `/osdy-pi header osdy-theme|neon` |
-| Mascot | `current` (default), `bts` | `/osdy-pi mascot current|bts` |
+| Mascot | `current` (default), `bts`, `osdy-halloween` | `/osdy-pi mascot current\|bts\|osdy-halloween` |
 
 Both commands update the UI immediately. Add `status` instead of a choice to inspect the current selection. Choices persist in the global Osdy Pi settings across reloads and sessions. The old top-level style commands and `classic` header aliases are no longer registered.
 
+Choose **Osdy-Halloween** in `/osdyConfig` → **Mascot**, or run `/osdy-pi mascot osdy-halloween`. It dresses the same Current raccoon in ivory fangs and a high-collared dark/crimson vampire cape. Its glow follows the active theme's `accent`, `mdHeading`, and `mdLink` colors; no Halloween theme is required. Current remains the default, and Current/Bts artwork and version-1 settings compatibility are unchanged.
+
 The header also shows **`osdy-pi v<version>`** at the top right in the theme's accent color, read from the installed Osdy package—not Pi's host version or the workspace manifest. It uses an empty first row or adds a row without overwriting artwork; invalid/unreadable versions or labels wider than the terminal are omitted.
 
 In normal mode, the selected header and mascot render side by side when both fit. The Neon header derives its highlights from the active theme rather than using one fixed palette. Each mascot keeps its own tone map while its animated edge glow can resolve through theme colors. Header and mascot scaling remain independent, so any combination follows the same responsive layout rules.
@@ -407,7 +409,7 @@ The enabled state, editor mode, working-tree visibility preference, header, and
 | TODO selection | `/osdy-pi todo on\|off\|status` |
 | Session TODO (opt-in, starting in 1.5.0) | `/todos` (read-only) |
 | Header | `/osdy-pi header osdy-theme\|neon\|status` |
-| Mascot | `/osdy-pi mascot current\|bts\|status` |
+| Mascot | `/osdy-pi mascot current\|bts\|osdy-halloween\|status` |
 | Editor | `/osdy-pi editor auto\|extended\|simple\|on\|off\|toggle\|status` |
 | Working tree | `/osdy-pi working-tree on\|off\|toggle\|status` |
 | Working tree | `/osdy-pi working-tree position top\|bottom\|status` |
@@ -492,14 +494,14 @@ While work is active, Osdy Pi centers an activity label and compact animated gly
 
 | Source | Example | Meaning |
 | --- | --- | --- |
-| Validated public `agent` argument | `explore · Working...` | Generic fallback, not measured progress or a claimed editing operation. This provider-neutral fallback works with Gentle Agents, which currently emits no live child progress. |
-| Public foreground progress from Joker (`pi-subagents-j0k3r`) | `scout · Exploring...` | Named `read` activity selects both the Exploring label and its existing glyph frames, overriding fallback. |
+| Validated public `agent` argument | `Working...` | Generic fallback, not measured progress or a claimed editing operation. This provider-neutral fallback works with Gentle Agents, which currently emits no live child progress. |
+| Public foreground progress from Joker (`pi-subagents-j0k3r`) | `Exploring...` | Named `read` activity selects both the Exploring label and its existing glyph frames, overriding fallback. |
 
-Live child activity uses the same six states and corresponding animated glyphs listed above, retaining the agent prefix: `scout · Thinking...`, `Exploring...`, `Verifying...`, `Working...`, `Delegating...`, or `Executing...`. Both public thinking and response streaming select Thinking; model labels, reasoning and response text are never read. Named reads/searches/direct documentation tools select Exploring, `lens_diagnostics` selects Verifying, edits/writes select Working, and `subagent_run` selects Delegating. Only named checks qualify: public tool metadata lacks arguments, so `bash`, wrappers needing selectors, and unknown tool names select Executing. Tool completion/failure events classify the reported operation while the child is running; they do not claim whole-task completion.
+Live child activity uses the same six states and corresponding animated glyphs listed above, without agent names: `Thinking...`, `Exploring...`, `Verifying...`, `Working...`, `Delegating...`, or `Executing...`. Both public thinking and response streaming select Thinking; model labels, reasoning and response text are never read. Named reads/searches/direct documentation tools select Exploring, `lens_diagnostics` selects Verifying, edits/writes select Working, and `subagent_run` selects Delegating. Only named checks qualify: public tool metadata lacks arguments, so `bash`, wrappers needing selectors, and unknown tool names select Executing. Tool completion/failure events classify the reported operation while the child is running; they do not claim whole-task completion.
 
-The fallback is `<agent> · Working...` **with the Working glyph**, regardless of optional `label` metadata. Missing or empty tool names supply no usable operation; named unknown tools instead select Executing. A continuation with an absent agent uses `Subagent`, never an inferred identity; missing/invalid run identity or explicitly invalid continuation identity fails closed to ordinary parent activity unless a live snapshot supplies its own validated public agent. Full tasks, prompts, context, content, trails and transcripts are never read or displayed.
+The fallback is `Working...` **with the Working glyph**, regardless of optional `label` metadata. Missing or empty tool names supply no usable operation; named unknown tools instead select Executing. A continuation with an absent agent validates the generic `Subagent` identity without displaying it, never inferring an identity; missing/invalid run identity or explicitly invalid continuation identity fails closed to ordinary parent activity unless a live snapshot supplies its own validated public agent. Full tasks, prompts, context, content, trails and transcripts are never read or displayed.
 
-For multiple running children, the indicator uses the first child in snapshot order with a compact additional-child count. Missing, malformed, terminal or no-running-child progress restores both the agent's generic fallback text and Working glyph, or ordinary parent activity when validated agent identity is unavailable. Labels are bounded, control-safe and clipped to terminal width. Matching tool end, agent/session end and reload cleanup discard per-call state.
+For multiple running children, the indicator uses the first child in snapshot order with a compact additional-child count (`(+N)`). Missing, malformed, terminal or no-running-child progress restores both the generic `Working...` fallback text and Working glyph, or ordinary parent activity when validated agent identity is unavailable. Labels are bounded, control-safe and clipped to terminal width. Matching tool end, agent/session end and reload cleanup discard per-call state.
 
 **Background limitation:** agent fallbacks appear only while their parent call is active. There is no persistent background live feed, polling or task cache.
 

package/extensions/osdy-pi/animation.test.ts

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { registerHooks } from "node:module";
 import test from "node:test";
 // @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
-import { HEADER_VARIANTS } from "./constants.ts";
+import { HEADER_VARIANTS, mascotForChoice } from "./constants.ts";
 import type { SimpleTheme } from "./types.js";
 
 registerHooks({
@@ -19,7 +19,7 @@ registerHooks({
 });
 
 // @ts-expect-error Node's native TypeScript runner resolves test-only TypeScript source imports.
-const { colorAsciiCharacter } = await import("./animation.ts");
+const { colorAsciiCharacter, animateAsciiLineWithToneMap } = await import("./animation.ts");
 
 class RecordingTheme implements SimpleTheme {
 	readonly calls: Array<{ name: string; text: string }> = [];
@@ -74,6 +74,33 @@ void test("Neon renders main and dark pink through bounded accent styling", () =
 	assert.equal(`${main}${dark.join("")}`.includes("\u001B[48;"), false);
 });
 
+void test("Osdy-Halloween resolves edge glow against the live theme in static and animated frames", () => {
+	const { art, tonePalette } = mascotForChoice("osdy-halloween");
+	assert.deepEqual([tonePalette.p, tonePalette.c, tonePalette.v], ["accent", "mdHeading", "mdLink"]);
+	let themeId = "first";
+	const calls: string[] = [];
+	const theme: SimpleTheme = { fg(name, text) { calls.push(name); return `<${themeId}:${name}:${text}>`; } };
+	for (const style of ["static", "animated"] as const) {
+		for (const frame of [0, 7, 28]) {
+			const render = () => art.mascot.map((line, row) =>
+				animateAsciiLineWithToneMap(line, art.toneMap[row] ?? "", row, frame, theme, tonePalette, style)).join("\n");
+			themeId = "first";
+			const first = render();
+			themeId = "second";
+			const second = render();
+			assert.notEqual(first, second);
+			assert.equal(first.replaceAll("first:", "second:"), second, "only theme-resolved colors change");
+			assert.ok(second.includes("\u001B[38;2;"), "fixed body/costume foreground colors remain");
+			assert.ok(!second.includes("\u001B[48;"), "transparent background");
+		}
+	}
+	assert.deepEqual([...new Set(calls)].sort(), ["accent", "mdHeading", "mdLink"].sort());
+	for (let row = 0; row < art.mascot.length; row++) {
+		const occupied = Array.from(art.mascot[row] ?? "").flatMap((glyph, column) => glyph === " " ? [] : [column]);
+		assert.deepEqual(occupied.slice(-3).reverse().map((column) => art.toneMap[row]?.[column]), ["p", "c", "v"].slice(0, occupied.length));
+	}
+});
+
 void test("Neon never maps a tone to mdHeading or mdLink", () => {
 	for (const color of Object.values(neonPalette())) {
 		if (typeof color === "string") {

package/extensions/osdy-pi/constants.ts

@@ -457,6 +457,52 @@ function addRightEdgeGlow(art: MascotArt): MascotArt {
   };
 }
 
+// Transparent overlay at Current's mouth/shoulders (row 17 onward).
+// ▓ = dark cape, ▒ = crimson lining, █/▼ = ivory fangs. Keep the face and tail.
+const VAMPIRE_COSTUME = [
+  "        ▓                                     ▓",
+  "         ▓▒▓          █          █         ▓▒▒▓",
+  "          ▓▒▒▒▓       ▼          ▼      ▓▒▒▒▒▓",
+  "           ▓▒▒▒▒▒▒▓                 ▓▒▒▒▒▒▒▓",
+  "            ▓▓▒▒▒▒▒▓▓             ▓▓▒▒▒▒▒▓▓",
+  "            ▓▓▓▒▒▒▓▓             ▓▓▒▒▒▓▓▓",
+  "           ▓▓▓▒▒▒▓▓               ▓▓▒▒▓▓▓",
+  "          ▓▓▓▒▒▒▓▓                ▓▓▒▒▒▓▓",
+  "         ▓▓▓▒▒▒▓▓                  ▓▓▒▒▓▓",
+  "        ▓▓▓▒▒▒▓▓                   ▓▓▒▒▓▓",
+  "       ▓▓▓▒▒▒▓▓                     ▓▓▒▒▓▓",
+  "      ▓▓▓▒▒▒▓▓                      ▓▓▒▒▓▓",
+  "     ▓▓▓▒▒▒▓▓                        ▓▓▒▒▓▓",
+  "    ▓▓▓▓▒▒▓▓                         ▓▓▒▒▓▓",
+  "   ▓▓▓▓▒▒▓▓                           ▓▓▒▓▓",
+  "    ▓▓▓▓▓▓                             ▓▓▓",
+] as const;
+
+function addVampireCostume(art: MascotArt): MascotArt {
+  const rows = art.mascot.map((line, row) => {
+    const glyphs = Array.from(line);
+    // Reserve b for lining; retain the few original eye glints in ivory h.
+    const tones = Array.from((art.toneMap[row] ?? "").replaceAll("b", "h"));
+    for (const [column, glyph] of Array.from(VAMPIRE_COSTUME[row - 17] ?? "").entries()) {
+      if (glyph === " ") continue;
+      glyphs[column] = glyph;
+      if (glyph === "▓") tones[column] = "d";
+      else if (glyph === "▒") tones[column] = "b";
+      else tones[column] = "h";
+    }
+    return { mascot: glyphs.join(""), toneMap: tones.join("") };
+  });
+  return { mascot: rows.map((row) => row.mascot), toneMap: rows.map((row) => row.toneMap) };
+}
+
+const HALLOWEEN_MASCOT_TONES: MascotTonePalette = {
+  ...HTML_MASCOT_TONES,
+  b: "#9F2342",
+};
+const HALLOWEEN_MASCOT = addRightEdgeGlow(addVampireCostume({
+  mascot: HTML_MASCOT,
+  toneMap: HTML_MASCOT_MAP,
+}));
 const ROSE_MASCOT = addRightEdgeGlow({
   mascot: HTML_MASCOT,
   toneMap: HTML_MASCOT_MAP,
@@ -468,6 +514,7 @@ const BTS_MASCOT_ART = addRightEdgeGlow({
 for (const [art, palette] of [
   [ROSE_MASCOT, HTML_MASCOT_TONES],
   [BTS_MASCOT_ART, BTS_MASCOT_TONES],
+  [HALLOWEEN_MASCOT, HALLOWEEN_MASCOT_TONES],
 ] as const) {
   assertRawHexPalette(palette);
   assertMascotStructure(art, palette);
@@ -481,6 +528,7 @@ export type MascotConfig = {
 export const MASCOTS: Record<MascotChoice, MascotConfig> = {
   current: { art: ROSE_MASCOT, tonePalette: HTML_MASCOT_TONES },
   bts: { art: BTS_MASCOT_ART, tonePalette: BTS_MASCOT_TONES },
+  "osdy-halloween": { art: HALLOWEEN_MASCOT, tonePalette: HALLOWEEN_MASCOT_TONES },
 };
 
 export function mascotForChoice(choice: MascotChoice): MascotConfig {

package/extensions/osdy-pi/control-center-preferences.test.ts

@@ -21,7 +21,7 @@ const snapshot: VisualPreferenceSnapshot = { enabled: true, headerVariant: "osdy
 void test("preference rows expose every catalog value and exactly one current indicator", () => {
 	for (const [category, field, values] of [
 		["Header", "headerVariant", ["osdy-theme", "neon"]],
-		["Mascot", "mascot", ["current", "bts"]],
+		["Mascot", "mascot", ["current", "bts", "osdy-halloween"]],
 		["Editor", "editorMode", ["auto", "extended", "simple"]],
 	] as const) {
 		for (const value of values) {
@@ -30,7 +30,9 @@ void test("preference rows expose every catalog value and exactly one current in
 			assert.deepEqual(detail.rows.map((row) => "value" in row.action ? row.action.value : undefined), values);
 			assert.equal(detail.rows.filter((row) => row.current).length, 1);
 			assert.equal(detail.rows.find((row) => row.current)?.action.kind, category.toLowerCase());
-			assert.match(detail.summary, new RegExp(`Current: ${value === "bts" ? "Bts" : value}`));
+			const label = value === "bts" ? "Bts" : value === "osdy-halloween" ? "Osdy-Halloween" : value;
+			assert.match(detail.summary, new RegExp(`Current: ${label}`));
+			assert.equal(detail.rows.find((row) => row.current)?.label, label);
 		}
 	}
 });

package/extensions/osdy-pi/control-center-preferences.ts

@@ -17,7 +17,11 @@ export interface ControlCenterPreferences {
 }
 
 export function visualPreferenceLabel(action: VisualPreferenceAction): string {
-	return action.kind === "mascot" && action.value === "bts" ? "Bts" : action.value;
+	if (action.kind === "mascot") {
+		if (action.value === "bts") return "Bts";
+		if (action.value === "osdy-halloween") return "Osdy-Halloween";
+	}
+	return action.value;
 }
 
 /** Explicit view adaptation only; application and persistence belong to runtime. */

package/extensions/osdy-pi/control-center.test.ts

@@ -336,7 +336,7 @@ void test("inline preferences show all supported values and live current/effecti
 	const f = preferenceFixture();
 	for (const [category, choices, current] of [
 		["Header", ["osdy-theme", "neon"], "osdy-theme"],
-		["Mascot", ["current", "Bts"], "current"],
+		["Mascot", ["current", "Bts", "Osdy-Halloween"], "current"],
 		["Editor", ["auto", "extended", "simple"], "auto"],
 	] as const) {
 		f.panel.handleInput(down);
@@ -350,6 +350,20 @@ void test("inline preferences show all supported values and live current/effecti
 	assert.deepEqual(f.applied, []);
 });
 
+void test("Mascot selects Osdy-Halloween and reports its exact saved label", async () => {
+	const f = preferenceFixture();
+	f.panel.handleInput(down);
+	f.panel.handleInput(down);
+	f.panel.handleInput(right);
+	f.panel.handleInput("\x1b[F");
+	f.panel.handleInput("\r");
+	assert.deepEqual(f.applied, [{ kind: "mascot", value: "osdy-halloween" }]);
+	assert.match(f.panel.render(100).join("\n"), /Saving.*Osdy-Halloween/);
+	f.complete(true);
+	await Promise.resolve();
+	assert.match(f.panel.render(100).join("\n"), /Saved globally: Osdy-Halloween/);
+});
+
 void test("changing categories resets selection to their current row, even after a longer theme list", () => {
 	const f = preferenceFixture();
 	f.panel.handleInput(right);
@@ -427,7 +441,7 @@ void test("inline preference rendering stays bounded at narrow widths and differ
 		f.panel.handleInput(down);
 		f.panel.handleInput(right);
 		f.panel.handleInput("\x1b[F");
-		assert.match(f.panel.render(48).join("\n"), new RegExp(`> ${["neon", "Bts", "simple"][category]}`));
+		assert.match(f.panel.render(48).join("\n"), new RegExp(`> ${["neon", "Osdy-Halloween", "simple"][category]}`));
 		for (const height of [1, 4, 7, 9, 18]) {
 			f.resize(height);
 			for (const width of [1, 8, 24, 48, 80]) {

package/extensions/osdy-pi/editor-settings.test.ts

@@ -97,7 +97,7 @@ void test("editor settings normalize only supported versioned modes", () => {
 });
 
 void test("mascot choices preserve the version-one current default, migrate raccoon to Bts, and persist Bts", async () => {
-	assert.deepEqual(MASCOT_CHOICES, ["current", "bts"]);
+	assert.deepEqual(MASCOT_CHOICES, ["current", "bts", "osdy-halloween"]);
 	assert.equal(
 		normalizeEditorSettings({ version: 1, mascot: "invalid" }).mascot,
 		"current",
@@ -129,6 +129,18 @@ void test("mascot choices preserve the version-one current default, migrate racc
 	assert.equal((await store.load()).mascot, "bts");
 });
 
+void test("Osdy-Halloween round-trips through a fresh version-one settings store", async () => {
+	const fileSystem = new MemoryEditorSettingsFileSystem();
+	const path = "/agent/extensions/osdy-pi/settings.json";
+	const settings = normalizeEditorSettings({ version: 1, mascot: "osdy-halloween" });
+	assert.equal(settings.mascot, "osdy-halloween");
+	await createEditorSettingsStore(path, fileSystem).save(settings);
+	const persisted: unknown = JSON.parse(fileSystem.content ?? "{}");
+	assert.deepEqual(persisted, { ...settings, version: 1 });
+	assert.deepEqual(await createEditorSettingsStore(path, fileSystem).load(), settings);
+	assert.equal(normalizeEditorSettings({ version: 2, mascot: "osdy-halloween" }).mascot, "current");
+});
+
 void test("enabled defaults safely and persists globally", async () => {
 	assert.equal(
 		normalizeEditorSettings({ version: 1, editorMode: "simple" }).enabled,

package/extensions/osdy-pi/runtime.test.ts

@@ -152,6 +152,7 @@ void test("shared visual actions apply immediately, save the complete settings,
 	for (const enabled of [true, false]) {
 		for (const action of [
 			{ kind: "header", value: "neon" }, { kind: "mascot", value: "bts" },
+			{ kind: "mascot", value: "osdy-halloween" },
 			{ kind: "editor", value: "simple" }, { kind: "editor", value: "extended" },
 			{ kind: "editor", value: "auto" },
 		] as const satisfies readonly VisualPreferenceAction[]) {
@@ -903,6 +904,7 @@ void test("registered legacy commands and osdyConfig share live values and exist
 		for (const [args, expected, field, value] of [
 			["header neon", "osdy-pi header: neon", "headerVariant", "neon"],
 			["mascot bts", "osdy-pi mascot: Bts", "mascot", "bts"],
+			["mascot osdy-halloween", "osdy-pi mascot: Osdy-Halloween", "mascot", "osdy-halloween"],
 			["editor off", "osdy-pi editor mode: simple", "editorMode", "simple"],
 			["editor on", "osdy-pi editor mode: extended", "editorMode", "extended"],
 			["editor toggle", "osdy-pi editor mode: simple", "editorMode", "simple"],
@@ -916,7 +918,9 @@ void test("registered legacy commands and osdyConfig share live values and exist
 		assert.equal(writes.at(-1)?.workingTreeEnabled, false);
 		assert.equal(notices.at(-1)?.message, "osdy-pi working tree disabled");
 		const before = writes.length;
-		for (const args of ["working-tree status", "header status", "mascot status", "editor status", "header invalid", "mascot bts extra", "editor simple extra"]) await legacy.handler(args, ctx);
+		await legacy.handler("mascot status", ctx);
+		assert.deepEqual(notices.at(-1), { message: "osdy-pi mascot: Osdy-Halloween", level: "info" });
+		for (const args of ["working-tree status", "header status", "mascot status", "editor status", "header invalid", "mascot bts extra", "mascot osdy-halloween extra", "mascot invalid", "editor simple extra"]) await legacy.handler(args, ctx);
 		assert.equal(writes.length, before, "status and invalid inputs never save");
 		const beforeModalGitCalls = gitCalls.length;
 		const beforeModalNotices = notices.length;
@@ -1348,15 +1352,19 @@ void test("uninstall command is offered and wired through guarded Pi CLI removal
  assert.match(source, /pi\.exec\("pi", \["remove", source/);
 });
 
-void test("mascot command completes current, Bts, and status while persisting with immediate refresh", () => {
+void test("mascot command completes all three choices and status while persisting with immediate refresh", () => {
 	assert.deepEqual(getOsdyCommandCompletions("mascot"), [
 		{ value: "mascot current", label: "mascot current" },
 		{ value: "mascot bts", label: "mascot bts" },
+		{ value: "mascot osdy-halloween", label: "mascot osdy-halloween" },
 		{ value: "mascot status", label: "mascot status" },
 	]);
 	assert.deepEqual(getOsdyCommandCompletions("mascot b"), [
 		{ value: "mascot bts", label: "mascot bts" },
 	]);
+	assert.deepEqual(getOsdyCommandCompletions("mascot o"), [
+		{ value: "mascot osdy-halloween", label: "mascot osdy-halloween" },
+	]);
 	assert.deepEqual(getOsdyCommandCompletions("mascot d"), []);
 
 	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");

package/extensions/osdy-pi/runtime.ts

@@ -128,6 +128,7 @@ function isMascotChoice(value: string): value is MascotChoice {
 }
 
 function mascotLabel(mascot: MascotChoice): string {
+	if (mascot === "osdy-halloween") return "Osdy-Halloween";
 	return mascot === "bts" ? "Bts" : mascot;
 }
 

package/extensions/osdy-pi/types.ts

@@ -44,7 +44,7 @@ export const HEADER_VARIANT_CHOICES = ["osdy-theme", "neon"] as const;
 
 export type HeaderVariant = (typeof HEADER_VARIANT_CHOICES)[number];
 
-export const MASCOT_CHOICES = ["current", "bts"] as const;
+export const MASCOT_CHOICES = ["current", "bts", "osdy-halloween"] as const;
 
 export type MascotChoice = (typeof MASCOT_CHOICES)[number];
 

package/extensions/osdy-pi/ui.test.ts

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { registerHooks } from "node:module";
 import { fileURLToPath } from "node:url";
@@ -244,12 +245,57 @@ void test("selected headers render through foreground-only tone-map animation",
 void test("mascot selection wires Bts art through the responsive renderer", () => {
 	const ui = readFileSync(new URL("./ui.ts", import.meta.url), "utf8");
 
-	assert.deepEqual(Object.keys(MASCOTS), ["current", "bts"]);
+	assert.deepEqual(Object.keys(MASCOTS), ["current", "bts", "osdy-halloween"]);
 	assert.ok(mascotForChoice("bts"));
 	assert.match(ui, /const mascot = mascotForChoice\(state\.mascot\);/);
 	assert.match(ui, /scaleMascot\(\s*mascot\.art,/);
 });
 
+void test("Current and Bts retain their original glyphs, tone maps, and palettes", () => {
+	for (const [choice, fingerprint] of [
+		["current", "5d399dc6d6cf7f88dce300ca224d157e23e21186b1991a4f57b65fe60c34d8ac"],
+		["bts", "e2040efe00cf709b799834d5183ddae3273cfb515b8dfa0f63ae1b9c5def71ec"],
+	] as const) {
+		assert.equal(createHash("sha256").update(JSON.stringify(MASCOTS[choice])).digest("hex"), fingerprint);
+	}
+});
+
+void test("Osdy-Halloween preserves Current's face and tail beneath a bounded vampire costume", () => {
+	const { art, tonePalette } = mascotForChoice("osdy-halloween");
+	const current = MASCOTS.current.art;
+	assert.deepEqual(art.mascot.slice(0, 17), current.mascot.slice(0, 17), "same ears, mask, eyes and snout");
+	for (let row = 21; row < current.mascot.length; row++) {
+		assert.equal(art.mascot[row]?.slice(44), current.mascot[row]?.slice(44), "original striped tail");
+	}
+	assert.notDeepEqual(art.mascot.slice(17), current.mascot.slice(17));
+	const fangs = art.mascot.slice(17, 20).join("\n");
+	assert.match(fangs, /▼[^▼\n]+▼/, "two ivory fang tips separated by the original muzzle");
+	assert.equal([...fangs].filter((glyph) => glyph === "▼").length, 2, "one-column fang tips");
+	assert.equal([...fangs].filter((glyph) => glyph === "█").length, 2, "one-column stems keep fangs two rows tall");
+	assert.equal(art.mascot.length, current.mascot.length);
+	assert.deepEqual(art.mascot.map((row) => row.length), current.mascot.map((row) => row.length));
+	assert.equal(art.toneMap[17]?.[8], "d", "raised collar has a dark outer edge");
+	assert.equal(art.toneMap[20]?.[12], "b", "collar has crimson lining");
+	assert.equal(tonePalette.b, "#9F2342");
+	assert.equal(tonePalette.d, MASCOTS.current.tonePalette.d);
+	for (const [width, rows] of [[100, 100], [48, 28], [32, 20], [1, 1]] as const) {
+		const scaled = scaleMascot(art, width, rows);
+		assert.ok(scaled.mascot.length <= rows);
+		assert.equal(scaled.mascot.length, scaled.toneMap.length);
+		if (width >= 32) assert.match(scaled.mascot.join("\n"), /▼+[^▼\n]+▼+/, "both fangs survive responsive sampling");
+		for (let row = 0; row < scaled.mascot.length; row++) {
+			const glyphs = Array.from(scaled.mascot[row] ?? "");
+			const tones = Array.from(scaled.toneMap[row] ?? "");
+			assert.ok(visibleWidth(scaled.mascot[row] ?? "") <= width);
+			assert.equal(glyphs.length, tones.length);
+			for (let column = 0; column < glyphs.length; column++) {
+				if (glyphs[column] !== " ") assert.ok(Object.keys(tonePalette).includes(tones[column] ?? ""));
+				if (glyphs[column] === "▼") assert.equal(tones[column], "h", "fangs retain ivory rather than glow/lining tones");
+			}
+		}
+	}
+});
+
 void test("Bts retains the 60 by 26 raccoon glyph structure and transparent tone cells", () => {
 	const art = MASCOTS.bts.art;
 	assert.equal(art.mascot.length, 26);

package/extensions/osdy-pi/working-child-activity.test.ts

@@ -9,24 +9,24 @@ registerHooks({ resolve(specifier, context, nextResolve) {
 	return nextResolve(specifier, context);
 } });
 const { childActivityState: activity, childAssignmentState: assignment } = await import("./working-child-activity.js");
-const working = (agent: string) => ({ activity: "working", label: `${agent} · Working...` });
+const working = () => ({ activity: "working", label: "Working..." });
 
 void test("fallback uses only validated public agent identity regardless of optional label", () => {
-	assert.deepEqual(assignment("subagent_run", { agent: "explore", label: "map footer data" }), working("explore"));
+	assert.deepEqual(assignment("subagent_run", { agent: "explore", label: "map footer data" }), working());
 	for (const args of [undefined, null, [], "scout", {}, { agent: 1 }, { agent: "\u0000\n" }, { agent: "a".repeat(4097) }, { label: "secret" }])
 		assert.equal(assignment("subagent_run", args), undefined);
 	for (const label of [undefined, null, 1, [], "", "\u0000", "x".repeat(4097)])
-		assert.deepEqual(assignment("subagent_run", { agent: "scout", label, task: "SECRET", prompt: "SECRET", context: "SECRET" }), working("scout"));
+		assert.deepEqual(assignment("subagent_run", { agent: "scout", label, task: "SECRET", prompt: "SECRET", context: "SECRET" }), working());
 	const metadata = { agent: "scout", get label() { throw new Error("label must not be read"); },
 		get task() { throw new Error("task must not be read"); }, get prompt() { throw new Error("prompt must not be read"); },
 		get context() { throw new Error("context must not be read"); } };
-	assert.deepEqual(assignment("subagent_run", metadata), working("scout"));
+	assert.deepEqual(assignment("subagent_run", metadata), working());
 	assert.equal(assignment("read", { agent: "scout" }), undefined);
-	assert.deepEqual(assignment("subagent_continue", { id: "scout" }), working("Subagent"));
+	assert.deepEqual(assignment("subagent_continue", { id: "scout" }), working());
 	for (const agent of [42, null, "", "\u0000"])
 		assert.equal(assignment("subagent_continue", { agent }), undefined);
-	assert.deepEqual(assignment("subagent_run", { agent: "\u001b[31m探索\u001b[0m\n\u202eagent" }), working("探索 agent"));
-	assert.deepEqual(assignment("subagent_run", { agent: "🙂".repeat(1000) }), working("🙂".repeat(32)));
+	assert.deepEqual(assignment("subagent_run", { agent: "\u001b[31m探索\u001b[0m\n\u202eagent" }), working());
+	assert.deepEqual(assignment("subagent_run", { agent: "🙂".repeat(1000) }), working());
 });
 
 function task(agent = "scout", kind = "tool_running", tool_names: unknown = ["read"]) {
@@ -54,18 +54,18 @@ void test("public operations return structured six-state activity and label", ()
 	];
 	for (const kind of ["tool_running", "tool_completed", "tool_failed"])
 		for (const [tool, state, label] of cases)
-			assert.deepEqual(activity(progress(task("scout", kind, [tool]))), { activity: state, label: `scout · ${label}` });
+			assert.deepEqual(activity(progress(task("scout", kind, [tool]))), { activity: state, label });
 	for (const kind of ["thinking", "streaming_response"])
-		assert.deepEqual(activity(progress(task("scout", kind))), { activity: "thinking", label: "scout · Thinking..." });
+		assert.deepEqual(activity(progress(task("scout", kind))), { activity: "thinking", label: "Thinking..." });
 });
 
 void test("multiple children select first running snapshot child and validate all children", () => {
 	assert.deepEqual(activity(progress({ agent: "old", status: "completed" }, task("first"), task("second"), task("third"))),
-		{ activity: "exploring", label: "first · Exploring... (+2)" });
-	assert.deepEqual(activity(progress(task("first", "tool_running", ["read", "write"]))), { activity: "exploring", label: "first · Exploring..." });
+		{ activity: "exploring", label: "Exploring... (+2)" });
+	assert.deepEqual(activity(progress(task("first", "tool_running", ["read", "write"]))), { activity: "exploring", label: "Exploring..." });
 	assert.equal(activity(progress(task(), task("bad", "tool_running", ["read", 1]))), undefined);
 	assert.equal(activity(progress(...Array.from({ length: 65 }, () => task()))), undefined);
-	assert.equal(activity(progress(...Array.from({ length: 64 }, () => task())))?.label, "scout · Exploring... (+63)");
+	assert.equal(activity(progress(...Array.from({ length: 64 }, () => task())))?.label, "Exploring... (+63)");
 });
 
 void test("terminal, missing, malformed and unsupported progress has no usable activity", () => {
@@ -90,16 +90,16 @@ void test("oversized snapshot agent is rejected despite otherwise valid live act
 	assert.equal(activity(progress(task("a".repeat(4097)))), undefined);
 });
 
-void test("snapshot agent at the input bound remains valid and is truncated for display", () => {
+void test("snapshot agent at the input bound remains valid without appearing in the label", () => {
 	assert.deepEqual(activity(progress(task("a".repeat(4096)))),
-		{ activity: "exploring", label: `${"a".repeat(32)} · Exploring...` });
+		{ activity: "exploring", label: "Exploring..." });
 });
 
 void test("external names are single-line, control-free and bounded before classification", () => {
 	const dirty = "\u001b[31mAgent\u001b[0m\n\t\u202eName\u0007";
 	assert.deepEqual(activity(progress(task(dirty, "tool_running", ["\u001b]0;title\u0007read\nfile"]))),
-		{ activity: "executing", label: "Agent Name · Executing..." });
+		{ activity: "executing", label: "Executing..." });
 	assert.deepEqual(activity(progress(task("a".repeat(1000), "tool_running", ["b".repeat(1000)]))),
-		{ activity: "executing", label: `${"a".repeat(32)} · Executing...` });
+		{ activity: "executing", label: "Executing..." });
 	assert.equal(activity(progress(task("\u0000\n"))), undefined);
 });

package/extensions/osdy-pi/working-child-activity.ts

@@ -4,8 +4,8 @@ import { classifyWorkingActivity, WORKING_ACTIVITY_LABELS } from "./working-acti
 
 export type ChildWorkingState = { activity: WorkingActivity; label: string };
 
-function childState(agent: string, activity: WorkingActivity): ChildWorkingState {
-	return { activity, label: `${agent} · ${WORKING_ACTIVITY_LABELS[activity]}` };
+function childState(activity: WorkingActivity): ChildWorkingState {
+	return { activity, label: WORKING_ACTIVITY_LABELS[activity] };
 }
 
 function record(value: unknown): value is Record<string, unknown> {
@@ -27,7 +27,7 @@ export function childAssignmentState(toolName: string, args: unknown): ChildWork
 	if (!record(args)) return undefined;
 	const agent = args.agent === undefined && toolName === "subagent_continue" ? "Subagent" : safeLabel(args.agent, 32);
 	if (!agent) return undefined;
-	return childState(agent, "working");
+	return childState("working");
 }
 
 function observableActivity(value: unknown): WorkingActivity | undefined {
@@ -63,7 +63,7 @@ export function childActivityState(partialResult: unknown): ChildWorkingState |
 		const agent = safeLabel(task.agent, 32);
 		const activity = record(task.live_activity) ? observableActivity(task.live_activity.current) : undefined;
 		if (!agent || !activity) return undefined;
-		first ??= childState(agent, activity);
+		first ??= childState(activity);
 		running++;
 	}
 	if (!first) return undefined;

package/extensions/osdy-pi/working-controller.test.ts

@@ -122,7 +122,7 @@ void test("child states select matching text and every existing glyph frame", (t
 	t.mock.timers.enable({ apis: ["setInterval"] });
 	const { working, controller: c } = fixture();
 	c.onToolStart("subagent_run", "child", { agent: "scout" });
-	assertDisplay(working, "working", "scout · Working...");
+	assertDisplay(working, "working", "Working...");
 	const cases: Array<[string, string | undefined, WorkingActivity, string]> = [
 		["thinking", undefined, "thinking", "Thinking..."],
 		["streaming_response", undefined, "thinking", "Thinking..."],
@@ -135,7 +135,7 @@ void test("child states select matching text and every existing glyph frame", (t
 	for (const [kind, tool, activity, label] of cases) {
 		c.onToolUpdate("subagent_run", "child", { details: { tasks: [{ agent: "scout", status: "running",
 			live_activity: { current: { kind, label: "IGNORED", tool_names: tool ? [tool] : undefined } } }] } });
-		assertDisplay(working, activity, `scout · ${label}`);
+		assertDisplay(working, activity, label);
 	}
 	c.onShutdown();
 });
@@ -145,21 +145,21 @@ void test("child updates respect tool identity and latest remaining tool ownersh
 	const { working, controller: c } = fixture();
 	c.onToolStart("subagent_run", "a");
 	c.onToolUpdate("subagent_run", "a", childProgress("scout"));
-	assertDisplay(working, "exploring", "scout · Exploring...");
+	assertDisplay(working, "exploring", "Exploring...");
 	c.onToolStart("subagent_run", "b");
 	c.onToolUpdate("subagent_run", "b", childProgress("writer", "edit"));
 	c.onToolUpdate("subagent_run", "a", childProgress("scout", "grep"));
 	c.onToolUpdate("read", "b", childProgress("wrong"));
 	c.onToolUpdate("subagent_run", "missing", childProgress("late"));
 	c.onToolEnd("missing");
-	assertDisplay(working, "working", "writer · Working...");
+	assertDisplay(working, "working", "Working...");
 	c.onToolStart("read", "ordinary");
 	c.onToolUpdate("subagent_run", "ordinary", childProgress("wrong"));
 	assert.equal(working.label, "Exploring...");
-	c.onToolEnd("ordinary"); assertDisplay(working, "working", "writer · Working...");
-	c.onToolEnd("b"); assertDisplay(working, "exploring", "scout · Exploring...");
+	c.onToolEnd("ordinary"); assertDisplay(working, "working", "Working...");
+	c.onToolEnd("b"); assertDisplay(working, "exploring", "Exploring...");
 	c.onToolUpdate("subagent_run", "b", childProgress("late"));
-	assertDisplay(working, "exploring", "scout · Exploring...");
+	assertDisplay(working, "exploring", "Exploring...");
 	c.onToolUpdate("subagent_run", "a", childProgress("scout", "read", "completed"));
 	assert.equal(working.label, "Delegating...");
 	c.onToolUpdate("subagent_run", "a", childProgress("scout"));
@@ -187,16 +187,16 @@ void test("agent fallback appears at start and resets after unavailable, malform
 	t.mock.timers.enable({ apis: ["setInterval"] });
 	const { working, controller: c } = fixture();
 	c.onToolStart("subagent_run", "a", { agent: "explore", label: "map footer data", task: "SECRET TASK", prompt: "SECRET PROMPT" });
-	assertDisplay(working, "working", "explore · Working...");
+	assertDisplay(working, "working", "Working...");
 	c.onToolUpdate("subagent_run", "a", childProgress("explore"));
-	assertDisplay(working, "exploring", "explore · Exploring...");
+	assertDisplay(working, "exploring", "Exploring...");
 	for (const update of [undefined, {}, { details: { tasks: null } }, { details: { tasks: [{ agent: "explore", status: "running" }] } }, childProgress("explore", "read", "completed"), childProgress("explore", ""),
 		{ details: { tasks: [{ agent: "explore", status: "running", live_activity: { current: { kind: "tool_running", tool_names: [] } } }] } },
 		{ details: { tasks: [{ agent: "explore", status: "running", live_activity: { current: { kind: "tool_running" } } }] } }]) {
 		c.onToolUpdate("subagent_run", "a", childProgress("explore"));
-		assertDisplay(working, "exploring", "explore · Exploring...");
+		assertDisplay(working, "exploring", "Exploring...");
 		c.onToolUpdate("subagent_run", "a", update);
-		assertDisplay(working, "working", "explore · Working...");
+		assertDisplay(working, "working", "Working...");
 	}
 	c.onToolEnd("a"); assert.equal(working.label, "Thinking...");
 });
@@ -205,28 +205,28 @@ void test("continuations use generic identity without guessing and preserve call
 	t.mock.timers.enable({ apis: ["setInterval"] });
 	const { working, controller: c } = fixture();
 	c.onToolStart("subagent_run", "a", { agent: "scout" });
-	assert.equal(working.label, "scout · Working...");
+	assert.equal(working.label, "Working...");
 	c.onToolStart("subagent_continue", "b", { id: "a", label: "check footer" });
-	assert.equal(working.label, "Subagent · Working...");
+	assert.equal(working.label, "Working...");
 	c.onToolStart("subagent_continue", "a", { agent: "wrong", label: "wrong" });
 	c.onToolUpdate("subagent_run", "b", childProgress("wrong"));
 	c.onToolUpdate("subagent_continue", "missing", childProgress("wrong"));
-	assert.equal(working.label, "Subagent · Working...");
+	assert.equal(working.label, "Working...");
 	c.onToolUpdate("subagent_continue", "b", childProgress("writer", "edit"));
-	assertDisplay(working, "working", "writer · Working...");
+	assertDisplay(working, "working", "Working...");
 	c.onToolUpdate("subagent_run", "a", childProgress("scout"));
-	assertDisplay(working, "working", "writer · Working...");
+	assertDisplay(working, "working", "Working...");
 	c.onToolUpdate("subagent_continue", "b", {});
-	assert.equal(working.label, "Subagent · Working...");
-	c.onToolEnd("b"); assertDisplay(working, "exploring", "scout · Exploring...");
+	assert.equal(working.label, "Working...");
+	c.onToolEnd("b"); assertDisplay(working, "exploring", "Exploring...");
 	c.onToolUpdate("subagent_continue", "b", childProgress("late"));
-	c.onToolUpdate("subagent_run", "a", {}); assert.equal(working.label, "scout · Working...");
+	c.onToolUpdate("subagent_run", "a", {}); assert.equal(working.label, "Working...");
 	c.onToolEnd("a");
 	c.onToolStart("subagent_continue", "c", { agent: "writer", label: "finish" });
-	assert.equal(working.label, "writer · Working...");
+	assert.equal(working.label, "Working...");
 	c.onToolEnd("c");
 	c.onToolStart("subagent_continue", "d", { id: "c", task: "SECRET" });
-	assert.equal(working.label, "Subagent · Working...");
+	assert.equal(working.label, "Working...");
 	c.onToolEnd("d");
 });
 
@@ -237,7 +237,7 @@ void test("identity failures stay parent-owned and live snapshots retain validat
 		c.onToolStart("subagent_run", "run", args);
 		assertDisplay(working, "delegating", "Delegating...");
 		c.onToolUpdate("subagent_run", "run", childProgress("public"));
-		assertDisplay(working, "exploring", "public · Exploring...");
+		assertDisplay(working, "exploring", "Exploring...");
 		c.onToolUpdate("subagent_run", "run", {});
 		assertDisplay(working, "delegating", "Delegating...");
 		c.onToolEnd("run");
@@ -246,17 +246,17 @@ void test("identity failures stay parent-owned and live snapshots retain validat
 	assertDisplay(working, "executing", "Executing...");
 	c.onToolEnd("continue");
 	c.onToolStart("subagent_continue", "continue", {});
-	assertDisplay(working, "working", "Subagent · Working...");
+	assertDisplay(working, "working", "Working...");
 	c.onToolUpdate("subagent_continue", "continue", { details: { tasks: [
 		{ agent: "first", status: "running", live_activity: { current: { kind: "tool_running", tool_names: ["read"] } } },
 		{ agent: "second", status: "running", live_activity: { current: { kind: "thinking" } } },
 	] } });
-	assertDisplay(working, "exploring", "first · Exploring... (+1)");
+	assertDisplay(working, "exploring", "Exploring... (+1)");
 	c.onToolStart("subagent_run", "continue", { agent: "wrong" });
 	c.onToolUpdate("subagent_run", "continue", childProgress("wrong"));
-	assertDisplay(working, "exploring", "first · Exploring... (+1)");
+	assertDisplay(working, "exploring", "Exploring... (+1)");
 	c.onToolUpdate("subagent_continue", "continue", {});
-	assertDisplay(working, "working", "Subagent · Working...");
+	assertDisplay(working, "working", "Working...");
 	c.onShutdown();
 });
 
@@ -265,7 +265,7 @@ void test("assignment metadata is cleared on agent and session cleanup", (t) =>
 	const { working, controller: c } = fixture();
 	for (const cleanup of [() => c.onAgentEnd(), () => c.onShutdown()]) {
 		c.onToolStart("subagent_run", "a", { agent: "scout", label: "map" });
-		assert.equal(working.label, "scout · Working...");
+		assert.equal(working.label, "Working...");
 		cleanup(); c.onToolUpdate("subagent_run", "a", childProgress("late"));
 		c.refreshWorking(); assert.equal(working.label, "Thinking...");
 		assert.equal(working.active, false); assert.equal(working.timer, undefined);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "osdy-pi",
-	"version": "1.11.8",
+	"version": "1.11.10",
 	"description": "Osdy Pi package: themes, header, and custom editor for Pi.",
 	"license": "MIT",
 	"type": "module",
@@ -83,7 +83,7 @@
 		"typescript": "^5.9.3",
 		"typescript-eslint": "^8.46.3"
 	},
-	"releaseSource": "f0af5964701aaf9022bb79d1ff2d25dbc389b7dc",
+	"releaseSource": "96f670c11788dfb1a336c664a266b8581546ff59",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/OsdyOrtiz/Osdy-Pi.git"