supipowers 2.2.2 → 2.2.3

package/README.md

@@ -36,6 +36,9 @@ The installer detects Pi (`~/.pi`) and OMP (`~/.omp`) — when both are present
 | [Bun](https://bun.sh)                                 | Runtime — required for installation and the built-in SQLite FTS index |
 | [Git](https://git-scm.com)                            | Used by the installer and git-based workflows                         |
 
+> [!TIP]
+> OMP ≥15.1.7 is recommended for best reliability with supipowers command-driven agent handoffs and accurate provider-scoped `/fast` status indicators. Older compatible OMP versions can run supipowers but lack those runtime fixes.
+
 ### Optional dependencies
 
 The installer scans for these and offers to install missing tooling where it can. Everything works without them, but each one unlocks additional capabilities.

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "supipowers",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "Workflow extension for OMP coding agents.",
   "type": "module",
   "scripts": {
     "test": "bun test --timeout 60000 --parallel tests/",
+    "test:windows": "bun test --timeout 60000 --parallel tests/platform/ tests/utils/editor.test.ts tests/utils/exec-cli.test.ts tests/fix-pr/scripts/exec.test.ts tests/mempalace/uv.test.ts tests/mempalace/git-hook.test.ts",
     "typecheck": "tsc --noEmit",
     "test:watch": "bun test --timeout 60000 --parallel --watch tests/",
     "test:evals": "bun test --timeout 60000 --parallel tests/evals/",
     "build": "tsc -p tsconfig.build.json",
-    "ci": "bun run typecheck && bun run test",
+    "ci": "bun run src/ci.ts",
     "install:visual-server": "npm --prefix src/visual/scripts ci --ignore-scripts --no-audit --no-fund",
     "postinstall": "bun run install:visual-server",
     "prepare": "git config core.hooksPath hooks || true",

package/skills/context-mode/SKILL.md

@@ -63,7 +63,7 @@ When OMP's `shellMinimizer` is active, large bash output ends with a `[raw outpu
 
 ### Read
 
-Reads are never blocked — OMP's native open/read tool preserves hashline anchors (e.g., `120th|content` after 14.4.1) for the edit contract. Large reads (>110 lines) are auto-compressed to head (80) + tail (30) with a `sel` hint.
+Reads are never blocked — OMP's native open/read tool preserves hashline anchors (e.g., `120th|content` after 14.4.1) for the edit contract. Copy edit anchors exactly, without the `|content` body, and never fabricate anchors. Edit payload lines must start with `~` immediately followed by intended file content; avoid a readability space after `~` unless that space is intentional file content. Large reads (>110 lines) are auto-compressed to head (80) + tail (30) with a `sel` hint.
 
 For analysis-only reads where anchors are not needed, prefer `ctx_execute_file(path, language, code)` — only your printed summary enters context.
 

package/src/ci.ts

@@ -0,0 +1,47 @@
+export type CiProfile = "default" | "windows-fast";
+
+export interface CiCommand {
+  label: string;
+  args: string[];
+}
+
+export function resolveCiProfile(value: string | undefined): CiProfile {
+  if (value === undefined || value === "" || value === "default") return "default";
+  if (value === "windows-fast") return "windows-fast";
+  throw new Error(`Unsupported SUPIPOWERS_CI_PROFILE: ${value}`);
+}
+
+export function getCiPlan(profile: CiProfile): CiCommand[] {
+  const typecheck = { label: "Typecheck", args: ["bun", "run", "typecheck"] };
+  if (profile === "windows-fast") {
+    return [
+      typecheck,
+      { label: "Windows portability tests", args: ["bun", "run", "test:windows"] },
+    ];
+  }
+
+  return [
+    typecheck,
+    { label: "Test", args: ["bun", "run", "test"] },
+  ];
+}
+
+export function runCi(profileValue: string | undefined = process.env.SUPIPOWERS_CI_PROFILE): number {
+  const profile = resolveCiProfile(profileValue);
+  for (const command of getCiPlan(profile)) {
+    console.log(`\n> ${command.label}`);
+    const result = Bun.spawnSync({
+      cmd: command.args,
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+      env: process.env,
+    });
+    if (!result.success) return result.exitCode;
+  }
+  return 0;
+}
+
+if (import.meta.main) {
+  process.exitCode = runCi();
+}

package/src/commands/doctor.ts

@@ -502,6 +502,7 @@ export function getDoctorRecommendations(): string[] {
   return [
     "Set `tools.elideFileMutationInputs: true` (OMP ≥14.7.0) — elides `write`/`edit`/`apply_patch` payloads from history after success. Saves significant context on long sessions like `/supi:ultraplan execute` and `/supi:harness implement`.",
     "Update to OMP ≥14.7.2 — fixes the `Working…` spinner staying active after read-only commands such as `/supi:status`, `/supi:doctor`, `/supi:context`, and `/supi:clear`. (oh-my-pi#927)",
+    "Use OMP ≥15.1.7 for best reliability — includes ACP fixes for command-driven agent handoffs and permission prompts, plus accurate provider-scoped `/fast` status-line indicators.",
   ];
 }
 

package/src/commands/memory.ts

@@ -6,17 +6,33 @@ import {
   snapshotMempalaceInstall,
   steerMempalaceInitialization,
 } from "../mempalace/installer-helper.js";
+import {
+  getMempalacePostCommitHookStatus,
+  installMempalacePostCommitHook,
+  uninstallMempalacePostCommitHook,
+  type MempalacePostCommitHookStatusResult,
+} from "../mempalace/git-hook.js";
 
 const SUBCOMMANDS = [
   { name: "status", description: "Show palace path, managed venv, and install status" },
   { name: "setup", description: "Install or repair the managed Python environment and MemPalace package" },
+  { name: "git-hook", description: "Manage the opt-in post-commit MemPalace reindex hook" },
+] as const;
+
+const GIT_HOOK_ACTIONS = [
+  { name: "status", description: "Show post-commit reindex hook status" },
+  { name: "install", description: "Install or update the post-commit reindex hook" },
+  { name: "uninstall", description: "Remove the managed hook and restore a chained user hook" },
 ] as const;
 
 const HELP = [
   "/supi:memory — native MemPalace integration",
   "",
   "Subcommands:",
-  ...SUBCOMMANDS.map((subcommand) => `  ${subcommand.name.padEnd(8)} ${subcommand.description}`),
+  ...SUBCOMMANDS.map((subcommand) => `  ${subcommand.name.padEnd(10)} ${subcommand.description}`),
+  "",
+  "Git hook:",
+  "  git-hook status|install|uninstall",
   "",
   "Memory APIs are exposed to the agent via the `mempalace` tool.",
 ].join("\n");
@@ -43,6 +59,80 @@ function statusReport(platform: Platform, cwd: string): string {
   return lines.join("\n");
 }
 
+function gitHookStatusReport(result: MempalacePostCommitHookStatusResult): string {
+  if (!result.ok) {
+    return [
+      "/supi:memory git-hook status",
+      "",
+      `status: unavailable (${result.code})`,
+      result.message,
+    ].join("\n");
+  }
+
+  return [
+    "/supi:memory git-hook status",
+    "",
+    `repo root: ${result.repoRoot}`,
+    `hooks dir: ${result.hooksDir}`,
+    `core.hooksPath: ${result.coreHooksPath ?? "(default .git/hooks)"}`,
+    `post-commit hook: ${result.installed ? "present" : "missing"}`,
+    `managed by supipowers: ${result.managed}`,
+    `chained user hook: ${result.userHookPresent ? result.userHookPath : "none"}`,
+    `reindex runner: ${result.runnerPresent ? result.runnerPath : `${result.runnerPath} (missing)`}`,
+  ].join("\n");
+}
+
+async function handleGitHook(platform: Platform, ctx: PlatformContext, action: string): Promise<void> {
+  const config = loadConfig(platform.paths, ctx.cwd);
+  const command = action || "status";
+
+  if (command === "status") {
+    const status = await getMempalacePostCommitHookStatus({
+      paths: platform.paths,
+      cwd: ctx.cwd,
+      config,
+      exec: platform.exec,
+    });
+    ctx.ui.notify(gitHookStatusReport(status), status.ok ? "info" : "warning");
+    return;
+  }
+
+  if (command === "install") {
+    const result = await installMempalacePostCommitHook({
+      paths: platform.paths,
+      cwd: ctx.cwd,
+      config,
+      exec: platform.exec,
+    });
+    if (result.ok) {
+      ctx.ui.notify(
+        `MemPalace post-commit reindex hook ${result.action}: ${result.hookPath}`,
+        "info",
+      );
+    } else {
+      ctx.ui.notify(`MemPalace post-commit hook install failed (${result.code}): ${result.message}`, "warning");
+    }
+    return;
+  }
+
+  if (command === "uninstall") {
+    const result = await uninstallMempalacePostCommitHook({
+      paths: platform.paths,
+      cwd: ctx.cwd,
+      config,
+      exec: platform.exec,
+    });
+    if (result.ok) {
+      ctx.ui.notify(`MemPalace post-commit reindex hook ${result.action}.`, "info");
+    } else {
+      ctx.ui.notify(`MemPalace post-commit hook uninstall failed (${result.code}): ${result.message}`, "warning");
+    }
+    return;
+  }
+
+  ctx.ui.notify(`Unknown /supi:memory git-hook action: ${command}\n\n${HELP}`, "warning");
+}
+
 async function runSetup(platform: Platform, ctx: PlatformContext): Promise<void> {
   const config = loadConfig(platform.paths, ctx.cwd);
   if (!config.mempalace.enabled) {
@@ -105,6 +195,26 @@ async function runSetup(platform: Platform, ctx: PlatformContext): Promise<void>
     "info",
   );
 
+
+  if (config.mempalace.hooks.postCommitReindex) {
+    const hookResult = await installMempalacePostCommitHook({
+      paths: platform.paths,
+      cwd: ctx.cwd,
+      config,
+      exec: platform.exec,
+    });
+    if (hookResult.ok) {
+      ctx.ui.notify(
+        `MemPalace post-commit reindex hook ${hookResult.action}: ${hookResult.hookPath}`,
+        "info",
+      );
+    } else {
+      ctx.ui.notify(
+        `MemPalace setup completed, but post-commit hook install failed (${hookResult.code}): ${hookResult.message}`,
+        "warning",
+      );
+    }
+  }
   // Check if the current project's wing is already initialized; if not, steer
   // the model to run init + mine through the mempalace tool.
   const initState = await checkMempalaceProjectInitialized({
@@ -141,8 +251,8 @@ async function runSetup(platform: Platform, ctx: PlatformContext): Promise<void>
 export function handleMemory(platform: Platform, ctx: PlatformContext, args?: string): void {
   if (!ctx.hasUI) return;
 
-  const sub = (args ?? "").trim().split(/\s+/)[0] ?? "";
-
+  const parts = (args ?? "").trim().split(/\s+/).filter(Boolean);
+  const sub = parts[0] ?? "";
   if (sub === "" || sub === "help" || sub === "--help" || sub === "-h") {
     ctx.ui.notify(HELP, "info");
     return;
@@ -168,14 +278,37 @@ export function handleMemory(platform: Platform, ctx: PlatformContext, args?: st
     return;
   }
 
+  if (sub === "git-hook") {
+    void (async () => {
+      try {
+        await handleGitHook(platform, ctx, parts[1] ?? "status");
+      } catch (err) {
+        ctx.ui.notify(`MemPalace git-hook command crashed: ${(err as Error).message}`, "error");
+      }
+    })();
+    return;
+  }
+
   ctx.ui.notify(`Unknown /supi:memory subcommand: ${sub}\n\n${HELP}`, "warning");
 }
 
 export function registerMemoryCommand(platform: Platform): void {
   platform.registerCommand("supi:memory", {
-    description: "Manage native MemPalace integration (status, setup)",
+    description: "Manage native MemPalace integration (status, setup, git-hook)",
     getArgumentCompletions(prefix: string) {
-      const lower = prefix.trim().toLowerCase();
+      const rawLower = prefix.toLowerCase();
+      const lower = rawLower.trim();
+      if (rawLower.startsWith("git-hook ")) {
+        const actionPrefix = rawLower.slice("git-hook ".length).trimStart();
+        const matches = GIT_HOOK_ACTIONS
+          .filter((action) => action.name.startsWith(actionPrefix))
+          .map((action) => ({
+            value: `git-hook ${action.name} `,
+            label: action.name,
+            description: action.description,
+          }));
+        return matches.length > 0 ? matches : null;
+      }
       const matches = SUBCOMMANDS
         .filter((subcommand) => subcommand.name.startsWith(lower))
         .map((subcommand) => ({

package/src/config/defaults.ts

@@ -74,9 +74,11 @@ export const DEFAULT_CONFIG: SupipowersConfig = {
     hooks: {
       wakeUp: true,
       searchGuidance: true,
+      writeGuidance: true,
       autoSearchOnPrompt: true,
       compactionCheckpoint: true,
       shutdownDiary: true,
+      postCommitReindex: false,
     },
     budgets: {
       wakeUpTokens: 1200,

package/src/config/schema.ts

@@ -109,9 +109,11 @@ export const ConfigSchema = z.object(
           {
             wakeUp: z.boolean(),
             searchGuidance: z.boolean(),
+            writeGuidance: z.boolean(),
             autoSearchOnPrompt: z.boolean(),
             compactionCheckpoint: z.boolean(),
             shutdownDiary: z.boolean(),
+            postCommitReindex: z.boolean(),
           },
         ).strict(),
         budgets: z.object(

package/src/context-mode/sandbox/executor.ts

@@ -20,6 +20,31 @@ export interface ExecuteResult {
 
 const DEFAULT_TIMEOUT = 30_000;
 
+const MISSING_BASH_EXIT_CODE = 127;
+function buildMissingBashMessage(platform: NodeJS.Platform): string {
+  const base = "bash is required to execute shell snippets.";
+  switch (platform) {
+    case "win32":
+      return `${base} Install Git for Windows or WSL, then retry.`;
+    case "darwin":
+      return `${base} Install bash via Homebrew (\`brew install bash\`) or Xcode Command Line Tools, then retry.`;
+    case "linux":
+      return `${base} Install bash via your distro's package manager (apt/yum/pacman), then retry.`;
+    default:
+      return `${base} Install bash for your platform and retry.`;
+  }
+}
+const MISSING_BASH_MESSAGE = buildMissingBashMessage(process.platform);
+
+function missingBashResult(startedAt: number): ExecuteResult {
+  return {
+    stdout: "",
+    stderr: MISSING_BASH_MESSAGE,
+    exitCode: MISSING_BASH_EXIT_CODE,
+    duration: performance.now() - startedAt,
+  };
+}
+
 export async function executeCode(
   language: string,
   code: string,
@@ -29,6 +54,11 @@ export async function executeCode(
   const opts = options ?? {};
   const timeout = opts.timeout ?? DEFAULT_TIMEOUT;
   const cwd = opts.cwd ?? process.cwd();
+  const start = performance.now();
+
+  if (language === "shell" && Bun.which("bash") === null) {
+    return missingBashResult(start);
+  }
 
   const id = randomUUID();
   const srcPath = path.join(os.tmpdir(), `ctx-exec-${id}${runner.fileExt}`);
@@ -37,7 +67,6 @@ export async function executeCode(
     : undefined;
 
   fs.writeFileSync(srcPath, code);
-  const start = performance.now();
 
   try {
     // Compile step for compiled languages

package/src/fix-pr/scripts/exec.ts

@@ -2,6 +2,35 @@ import { spawnSync } from "node:child_process";
 import type { ExecOptions, ExecResult, Platform } from "../../platform/types.js";
 import { findExecutable } from "../../utils/executable.js";
 
+export interface CliInvocation {
+  cmd: string;
+  args: string[];
+}
+
+function quoteCmdArgument(arg: string): string {
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+
+export function buildCliInvocation(
+  resolvedCommand: string,
+  args: string[],
+  platform: NodeJS.Platform = process.platform,
+): CliInvocation {
+  if (platform === "win32" && /\.(cmd|bat)$/i.test(resolvedCommand)) {
+    return {
+      cmd: "cmd.exe",
+      args: [
+        "/d",
+        "/s",
+        "/c",
+        `"${[resolvedCommand, ...args].map(quoteCmdArgument).join(" ")}"`,
+      ],
+    };
+  }
+
+  return { cmd: resolvedCommand, args };
+}
+
 export function runCliCommand(
   command: string,
   args: string[],
@@ -13,7 +42,9 @@ export function runCliCommand(
     pathext: env.PATHEXT,
   }) ?? command;
 
-  const result = spawnSync(resolvedCommand, args, {
+  const invocation = buildCliInvocation(resolvedCommand, args);
+
+  const result = spawnSync(invocation.cmd, invocation.args, {
     cwd: options?.cwd,
     env,
     encoding: "utf8",

package/src/harness/stages/implement-apply.ts

@@ -537,6 +537,7 @@ function renderGithubActionsWorkflow(spec: HarnessDesignSpec): string {
       "    runs-on: ubuntu-latest",
       "    steps:",
       "      - name: Reject PRs into main from non-dev branches",
+      "        shell: bash",
       "        run: |",
       `          if [ "${PR_HEAD_REF_EXPR}" != "${git.devBranch}" ]; then`,
       `            echo "PRs into '${git.mainBranch}' must come from '${git.devBranch}'." >&2`,

package/src/harness/storage.ts

@@ -15,6 +15,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 
 import type { PlatformPaths } from "../platform/types.js";
+import { ensureTrailingNewline, normalizeLineEndings } from "../text.js";
 import type {
   HarnessDesignSpec,
   HarnessDiscoverArtifact,
@@ -111,7 +112,7 @@ export function writeTextAtomic(
   try {
     ensureDir(filePath);
     const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-    fs.writeFileSync(tmpPath, content.endsWith("\n") ? content : `${content}\n`);
+    fs.writeFileSync(tmpPath, ensureTrailingNewline(normalizeLineEndings(content)));
     fs.renameSync(tmpPath, filePath);
     return success(filePath);
   } catch (error) {

package/src/mempalace/contract.ts

@@ -0,0 +1,32 @@
+import type { ResolvedMempalaceConfig } from "./config.js";
+
+export type MempalaceGuidanceMode = "full" | "refresher";
+
+export const MEMPALACE_TOOL_DESCRIPTION = [
+  "MemPalace memory dispatcher.",
+  "READ: **MUST** call `search` before answering past-fact questions unless the answer is fully derivable from the current turn or already-read files.",
+  "WRITE: **MUST NOT** add, update, or delete memory unless the user explicitly asks or the current system instructions direct a specific write.",
+  "NEVER call large mutators (`init`, `mine`, `split`, `repair`) unless explicitly instructed or running a setup/hook flow.",
+].join(" ");
+
+export function buildMempalaceGuidance(
+  hooks: Pick<ResolvedMempalaceConfig["hooks"], "searchGuidance" | "writeGuidance">,
+  mode: MempalaceGuidanceMode,
+): string[] {
+  const lines: string[] = [];
+  if (hooks.searchGuidance) {
+    lines.push(
+      mode === "full"
+        ? "## READ\n- You **MUST** call `mempalace(action=\"search\", query=...)` before answering questions about prior decisions, people, projects, past events, or anything you would otherwise answer from memory about this project.\n- You MAY skip search only when the answer is fully derivable from the current turn or files already read this turn. Reuse per-turn search results; do not repeat the same query."
+        : "- READ: **MUST** call `mempalace(action=\"search\", query=...)` before past-fact answers unless fully derivable this turn.",
+    );
+  }
+  if (hooks.writeGuidance) {
+    lines.push(
+      mode === "full"
+        ? "## WRITE\n- You **MUST NOT** call write/mutation actions (`add_drawer`, `update_drawer`, `delete_drawer`, `diary_write`, `kg_add`, `kg_invalidate`, `create_tunnel`, `delete_tunnel`) unless the user explicitly asks you to remember/save/log something or the current system instructions direct a specific write.\n- You **MUST NOT** infer that a decision, preference, or observation should be stored. If memory should be updated but no explicit write instruction exists, state that the user can ask you to remember it.\n- You **MUST NOT** call large indexing/repair actions (`init`, `mine`, `split`, `repair`) unless explicitly instructed or running an approved setup/hook flow."
+        : "- WRITE: **MUST NOT** mutate memory unless the user explicitly asks or current system instructions direct a specific write.",
+    );
+  }
+  return lines;
+}

package/src/mempalace/git-hook.ts

@@ -0,0 +1,443 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import type { Platform, PlatformPaths } from "../platform/types.js";
+import type { SupipowersConfig } from "../types.js";
+import { resolveMempalaceConfig } from "./config.js";
+import { snapshotMempalaceInstall, type MempalaceInstallSnapshot } from "./installer-helper.js";
+
+export const MEM_PALACE_POST_COMMIT_HOOK_MARKER = "supipowers-mempalace-post-commit v1";
+const POST_COMMIT_HOOK_NAME = "post-commit";
+const USER_POST_COMMIT_HOOK_NAME = "post-commit.user";
+const REINDEX_RUNNER_NAME = "supi-mempalace-reindex.py";
+const REINDEX_RUNNER_MARKER = "supipowers-mempalace-reindex-runner v1";
+const DEFAULT_REINDEX_TIMEOUT_SECONDS = 30;
+
+type ExecFn = Platform["exec"];
+
+export interface MempalaceGitHookContext {
+  repoRoot: string;
+  hooksDir: string;
+  hookPath: string;
+  userHookPath: string;
+  coreHooksPath: string | null;
+}
+
+type MempalaceGitHookContextFailure = { ok: false; code: "not_git_repo" | "git_failed"; message: string };
+
+export interface MempalacePostCommitHookStatus extends MempalaceGitHookContext {
+  ok: true;
+  installed: boolean;
+  managed: boolean;
+  userHookPresent: boolean;
+  runnerPath: string;
+  runnerPresent: boolean;
+}
+
+export type MempalacePostCommitHookStatusResult =
+  | MempalacePostCommitHookStatus
+  | { ok: false; code: "not_git_repo" | "git_failed"; message: string };
+
+type MempalacePostCommitHookInstallAction = "installed" | "already-installed" | "upgraded" | "chained-user-hook";
+type MempalacePostCommitHookUninstallAction = "uninstalled" | "restored-user-hook" | "already-uninstalled";
+
+export type MempalacePostCommitHookInstallResult =
+  | (MempalacePostCommitHookStatus & { action: MempalacePostCommitHookInstallAction })
+  | { ok: false; code: "mempalace_disabled" | "mempalace_not_ready" | "not_git_repo" | "user_hook_conflict" | "git_failed"; message: string };
+
+export type MempalacePostCommitHookUninstallResult =
+  | (MempalacePostCommitHookStatus & { action: MempalacePostCommitHookUninstallAction })
+  | { ok: false; code: "not_git_repo" | "not_managed" | "git_failed"; message: string };
+
+interface BaseHookOptions {
+  paths: PlatformPaths;
+  cwd: string;
+  config: SupipowersConfig;
+  exec: ExecFn;
+}
+
+export interface InstallMempalacePostCommitHookOptions extends BaseHookOptions {
+  snapshot?: MempalaceInstallSnapshot;
+}
+
+function trimStdout(value: string): string {
+  return value.trim().replace(/\r\n/g, "\n");
+}
+
+function resolveMaybeRelative(baseDir: string, value: string): string {
+  return path.isAbsolute(value) ? path.normalize(value) : path.resolve(baseDir, value);
+}
+
+async function gitValue(exec: ExecFn, cwd: string, args: string[]): Promise<{ ok: true; value: string } | { ok: false; message: string; code: number }> {
+  try {
+    const result = await exec("git", args, { cwd });
+    if (result.code !== 0) {
+      const detail = trimStdout(result.stderr || result.stdout) || `git ${args.join(" ")} exited ${result.code}`;
+      return { ok: false, message: detail, code: result.code };
+    }
+    return { ok: true, value: trimStdout(result.stdout) };
+  } catch (error) {
+    return { ok: false, message: error instanceof Error ? error.message : String(error), code: -1 };
+  }
+}
+
+async function resolveHookContext(exec: ExecFn, cwd: string): Promise<MempalaceGitHookContext | MempalaceGitHookContextFailure> {
+  const repoRootResult = await gitValue(exec, cwd, ["rev-parse", "--show-toplevel"]);
+  if (!repoRootResult.ok || repoRootResult.value.length === 0) {
+    return { ok: false, code: "not_git_repo", message: repoRootResult.ok ? "Not inside a git repository." : repoRootResult.message };
+  }
+
+  const repoRoot = path.resolve(repoRootResult.value);
+  const commonDirResult = await gitValue(exec, repoRoot, ["rev-parse", "--git-common-dir"]);
+  if (!commonDirResult.ok || commonDirResult.value.length === 0) {
+    return { ok: false, code: "git_failed", message: commonDirResult.ok ? "git rev-parse --git-common-dir returned an empty path." : commonDirResult.message };
+  }
+
+  const coreHooksPathResult = await gitValue(exec, repoRoot, ["config", "--get", "core.hooksPath"]);
+  let coreHooksPath: string | null = null;
+  if (coreHooksPathResult.ok) {
+    coreHooksPath = coreHooksPathResult.value.length > 0 ? coreHooksPathResult.value : null;
+  } else if (coreHooksPathResult.code !== 1) {
+    // git exits 1 when the config key is unset (expected). Any other code is
+    // a real failure (corrupt config, permission error) and must not silently
+    // fall back to the default hooks dir.
+    return { ok: false, code: "git_failed", message: coreHooksPathResult.message };
+  }
+  const hooksDir = coreHooksPath !== null
+    ? resolveMaybeRelative(repoRoot, coreHooksPath)
+    : path.join(resolveMaybeRelative(repoRoot, commonDirResult.value), "hooks");
+
+  return {
+    repoRoot,
+    hooksDir,
+    hookPath: path.join(hooksDir, POST_COMMIT_HOOK_NAME),
+    userHookPath: path.join(hooksDir, USER_POST_COMMIT_HOOK_NAME),
+    coreHooksPath,
+  };
+}
+
+function isHookContextFailure(value: MempalaceGitHookContext | MempalaceGitHookContextFailure): value is MempalaceGitHookContextFailure {
+  return "ok" in value && value.ok === false;
+}
+
+function readTextIfPresent(filePath: string): string | null {
+  try {
+    return fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : null;
+  } catch {
+    return null;
+  }
+}
+
+function isManagedHook(content: string | null): boolean {
+  return content !== null && content.includes(MEM_PALACE_POST_COMMIT_HOOK_MARKER);
+}
+
+function writeExecutableFile(filePath: string, content: string): boolean {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const existing = readTextIfPresent(filePath);
+  if (existing === content) {
+    chmodExecutableBestEffort(filePath);
+    return false;
+  }
+  fs.writeFileSync(filePath, content, "utf-8");
+  chmodExecutableBestEffort(filePath);
+  return true;
+}
+
+function chmodExecutableBestEffort(filePath: string): void {
+  try {
+    fs.chmodSync(filePath, 0o755);
+  } catch (error) {
+    if (process.platform !== "win32") throw error;
+  }
+}
+
+export function toHookShellPath(value: string, platform: NodeJS.Platform = process.platform): string {
+  return platform === "win32" ? value.replace(/\\/g, "/") : value;
+}
+
+function shQuote(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+function buildPostCommitHookScript(snapshot: MempalaceInstallSnapshot, runnerPath: string, palacePath: string, agentName: string): string {
+  const python = shQuote(toHookShellPath(snapshot.venvPython));
+  const runner = shQuote(toHookShellPath(runnerPath));
+  const bridge = shQuote(toHookShellPath(snapshot.bridgePath));
+  const palace = shQuote(toHookShellPath(palacePath));
+  const agent = shQuote(agentName);
+  return `#!/bin/sh
+# ${MEM_PALACE_POST_COMMIT_HOOK_MARKER}
+# Managed by /supi:memory git-hook install. Chains ${USER_POST_COMMIT_HOOK_NAME} when present.
+
+USER_HOOK="$(dirname "$0")/${USER_POST_COMMIT_HOOK_NAME}"
+USER_STATUS=0
+if [ -f "$USER_HOOK" ]; then
+  if [ -x "$USER_HOOK" ]; then
+    "$USER_HOOK" "$@"
+  else
+    sh "$USER_HOOK" "$@"
+  fi
+  USER_STATUS=$?
+fi
+
+REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null) || exit "$USER_STATUS"
+HEAD_COMMIT=$(git rev-parse HEAD 2>/dev/null) || exit "$USER_STATUS"
+PYTHON=${python}
+RUNNER=${runner}
+BRIDGE=${bridge}
+PALACE=${palace}
+AGENT=${agent}
+
+[ -f "$PYTHON" ] || exit "$USER_STATUS"
+[ -f "$RUNNER" ] || exit "$USER_STATUS"
+[ -f "$BRIDGE" ] || exit "$USER_STATUS"
+
+LOG_DIR="$REPO_ROOT/.omp/supipowers/mempalace"
+LOG="$LOG_DIR/post-commit.log"
+mkdir -p "$LOG_DIR" 2>/dev/null || exit "$USER_STATUS"
+(
+  "$PYTHON" "$RUNNER" \
+    --cwd "$REPO_ROOT" \
+    --commit "$HEAD_COMMIT" \
+    --bridge "$BRIDGE" \
+    --palace "$PALACE" \
+    --agent "$AGENT" \
+    --timeout-seconds ${DEFAULT_REINDEX_TIMEOUT_SECONDS} \
+    >> "$LOG" 2>&1
+) &
+exit "$USER_STATUS"
+`;
+}
+
+function buildReindexRunnerScript(): string {
+  return `#!/usr/bin/env python3
+# ${REINDEX_RUNNER_MARKER}
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from typing import Iterable
+
+
+def _decode_paths(raw: bytes) -> list[str]:
+    return [part.decode("utf-8", "surrogateescape") for part in raw.split(b"\\0") if part]
+
+
+def _changed_files(cwd: str, commit: str, timeout_seconds: int) -> list[str]:
+    proc = subprocess.run(
+        [
+            "git",
+            "diff-tree",
+            "--root",
+            "--no-commit-id",
+            "--name-only",
+            "-r",
+            "-z",
+            "--diff-filter=ACMRT",
+            commit,
+        ],
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        timeout=timeout_seconds,
+    )
+    if proc.returncode != 0:
+        stderr = proc.stderr.decode("utf-8", "replace").strip()
+        print(f"[supi-mempalace] git diff-tree failed: {stderr}", file=sys.stderr)
+        return []
+    return _decode_paths(proc.stdout)
+
+
+def _safe_existing_files(cwd: str, paths: Iterable[str]) -> list[str]:
+    root = os.path.abspath(cwd)
+    selected: list[str] = []
+    for rel in paths:
+        abs_path = os.path.abspath(os.path.join(root, rel))
+        try:
+            if os.path.commonpath([root, abs_path]) != root:
+                print(f"[supi-mempalace] skip outside repo: {rel}")
+                continue
+        except ValueError:
+            print(f"[supi-mempalace] skip outside repo: {rel}")
+            continue
+        if os.path.isfile(abs_path):
+            selected.append(rel)
+    return selected
+
+
+def _run_split(args: argparse.Namespace, source_file: str) -> bool:
+    request = {
+        "action": "split",
+        "params": {"source_file": source_file},
+        "options": {
+            "cwd": args.cwd,
+            "palacePath": args.palace,
+            "agentName": args.agent,
+        },
+    }
+    try:
+        proc = subprocess.run(
+            [sys.executable, args.bridge],
+            cwd=args.cwd,
+            input=json.dumps(request),
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=args.timeout_seconds,
+        )
+    except subprocess.TimeoutExpired:
+        print(f"[supi-mempalace] split timed out: {source_file}", file=sys.stderr)
+        return False
+
+    if proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout).strip()
+        print(f"[supi-mempalace] bridge failed for {source_file}: {detail}", file=sys.stderr)
+        return False
+
+    try:
+        payload = json.loads(proc.stdout or "{}")
+    except json.JSONDecodeError:
+        print(f"[supi-mempalace] bridge returned non-json for {source_file}: {proc.stdout[:300]}", file=sys.stderr)
+        return False
+
+    if payload.get("ok") is True:
+        print(f"[supi-mempalace] indexed {source_file}")
+        return True
+
+    error = payload.get("error") if isinstance(payload.get("error"), dict) else {}
+    code = error.get("code", "unknown_error")
+    message = error.get("message", "MemPalace split failed")
+    print(f"[supi-mempalace] split failed for {source_file}: {code}: {message}", file=sys.stderr)
+    return False
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Reindex MemPalace drawers for files changed by one git commit.")
+    parser.add_argument("--cwd", required=True)
+    parser.add_argument("--commit", required=True)
+    parser.add_argument("--bridge", required=True)
+    parser.add_argument("--palace", required=True)
+    parser.add_argument("--agent", required=True)
+    parser.add_argument("--timeout-seconds", type=int, default=30)
+    args = parser.parse_args()
+
+    if not os.path.isfile(args.bridge):
+        print(f"[supi-mempalace] bridge missing: {args.bridge}", file=sys.stderr)
+        return 0
+
+    timeout_seconds = max(1, args.timeout_seconds)
+    args.timeout_seconds = timeout_seconds
+    changed = _changed_files(args.cwd, args.commit, timeout_seconds)
+    files = _safe_existing_files(args.cwd, changed)
+    if not files:
+        print(f"[supi-mempalace] commit {args.commit}: no indexable changed files")
+        return 0
+
+    ok = 0
+    for source_file in files:
+        if _run_split(args, source_file):
+            ok += 1
+    print(f"[supi-mempalace] commit {args.commit}: indexed {ok}/{len(files)} file(s)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+`;
+}
+
+function buildStatus(context: MempalaceGitHookContext, runnerPath: string): MempalacePostCommitHookStatus {
+  const hookContent = readTextIfPresent(context.hookPath);
+  return {
+    ok: true,
+    ...context,
+    installed: hookContent !== null,
+    managed: isManagedHook(hookContent),
+    userHookPresent: fs.existsSync(context.userHookPath),
+    runnerPath,
+    runnerPresent: fs.existsSync(runnerPath),
+  };
+}
+
+export async function getMempalacePostCommitHookStatus(options: BaseHookOptions): Promise<MempalacePostCommitHookStatusResult> {
+  const context = await resolveHookContext(options.exec, options.cwd);
+  if (isHookContextFailure(context)) return context;
+  return buildStatus(context, options.paths.global("bin", REINDEX_RUNNER_NAME));
+}
+
+export async function installMempalacePostCommitHook(options: InstallMempalacePostCommitHookOptions): Promise<MempalacePostCommitHookInstallResult> {
+  if (!options.config.mempalace.enabled) {
+    return { ok: false, code: "mempalace_disabled", message: "MemPalace integration is disabled in config." };
+  }
+
+  const snapshot = options.snapshot ?? snapshotMempalaceInstall(options.paths, options.cwd, options.config);
+  if (!snapshot.ready) {
+    return { ok: false, code: "mempalace_not_ready", message: "MemPalace runtime is not ready. Run /supi:memory setup before installing the git hook." };
+  }
+
+  const context = await resolveHookContext(options.exec, options.cwd);
+  if (isHookContextFailure(context)) return context;
+
+  const resolved = resolveMempalaceConfig(options.config, context.repoRoot, options.paths);
+  const runnerPath = options.paths.global("bin", REINDEX_RUNNER_NAME);
+
+  const desiredHook = buildPostCommitHookScript(snapshot, runnerPath, resolved.palacePath, resolved.defaultAgentName);
+  const existingHook = readTextIfPresent(context.hookPath);
+
+  // Refuse the install before writing any artifacts: when there is a
+  // non-managed active hook AND the chained user slot is already taken,
+  // we have nowhere to move the existing hook to.
+  if (existingHook !== null && !isManagedHook(existingHook) && fs.existsSync(context.userHookPath)) {
+    return {
+      ok: false,
+      code: "user_hook_conflict",
+      message: `Cannot install MemPalace post-commit hook because both ${context.hookPath} and ${context.userHookPath} already exist and the active hook is not managed by supipowers.`,
+    };
+  }
+
+  writeExecutableFile(runnerPath, buildReindexRunnerScript());
+
+  if (existingHook === desiredHook) {
+    return { ...buildStatus(context, runnerPath), action: "already-installed" };
+  }
+
+  fs.mkdirSync(context.hooksDir, { recursive: true });
+  let action: MempalacePostCommitHookInstallAction = "installed";
+  if (existingHook !== null && !isManagedHook(existingHook)) {
+    fs.renameSync(context.hookPath, context.userHookPath);
+    action = "chained-user-hook";
+  } else if (existingHook !== null) {
+    action = "upgraded";
+  }
+
+  writeExecutableFile(context.hookPath, desiredHook);
+  return { ...buildStatus(context, runnerPath), action };
+}
+
+export async function uninstallMempalacePostCommitHook(options: BaseHookOptions): Promise<MempalacePostCommitHookUninstallResult> {
+  const context = await resolveHookContext(options.exec, options.cwd);
+  if (isHookContextFailure(context)) return context;
+
+  const runnerPath = options.paths.global("bin", REINDEX_RUNNER_NAME);
+  const existingHook = readTextIfPresent(context.hookPath);
+  if (existingHook !== null && !isManagedHook(existingHook)) {
+    return { ok: false, code: "not_managed", message: `${context.hookPath} is not managed by supipowers; refusing to remove it.` };
+  }
+
+  if (existingHook !== null) {
+    fs.rmSync(context.hookPath, { force: true });
+  }
+
+  let action: MempalacePostCommitHookUninstallAction = existingHook === null ? "already-uninstalled" : "uninstalled";
+  if (fs.existsSync(context.userHookPath) && !fs.existsSync(context.hookPath)) {
+    fs.renameSync(context.userHookPath, context.hookPath);
+    chmodExecutableBestEffort(context.hookPath);
+    action = "restored-user-hook";
+  }
+
+  return { ...buildStatus(context, runnerPath), action };
+}

package/src/mempalace/hooks.ts

@@ -7,6 +7,7 @@ import { resolveInstalledBridgeScriptPath } from "./runtime.js";
 import { getEventStore as getContextEventStore, getSessionId as getContextSessionId } from "../context-mode/hooks.js";
 import { buildCompactionCheckpoint, buildShutdownDiary } from "./session-summary.js";
 import { snapshotMempalaceInstall } from "./installer-helper.js";
+import { buildMempalaceGuidance } from "./contract.js";
 
 export interface MempalaceHooksDeps {
   createBridge?: (config: ResolvedMempalaceConfig, cwd: string) => MempalaceBridgeFacade;
@@ -162,12 +163,9 @@ function wakeUpBlock(resolved: ResolvedMempalaceConfig, wing: string, text: stri
     "# MemPalace memory",
     `- palace: ${resolved.palacePath}`,
     `- default wing: ${wing}`,
-  ];
-  if (resolved.hooks.searchGuidance) {
-    lines.push(
-      "- You **MUST** call `mempalace(action=\"search\", query=...)` before answering questions about prior decisions, people, projects, or past events. Skip only when the answer is fully derivable from the current turn or the active codebase.",
-    );
-  }
+    "",
+    ...buildMempalaceGuidance(resolved.hooks, "full"),
+  ].filter((line) => line.length > 0);
   if (excerpt.trim()) {
     lines.push("", "## Wake-up excerpt", excerpt.trim());
   }
@@ -175,19 +173,15 @@ function wakeUpBlock(resolved: ResolvedMempalaceConfig, wing: string, text: stri
 }
 
 /**
- * Compact one-line refresher injected on turns where we skip the full
- * wake-up dump. Keeps the model oriented (palace/wing) and re-asserts the
- * RFC-2119 search nudge in ~140 chars instead of ~870 tokens.
+ * Compact refresher injected on turns where we skip the full wake-up dump.
+ * Keeps the model oriented (palace/wing) and re-asserts the MemPalace
+ * read/write contract without paying for the wake-up excerpt.
  */
 function wakeUpRefresher(resolved: ResolvedMempalaceConfig, wing: string): string {
   const lines = [
     `# MemPalace memory: wing=${wing}`,
+    ...buildMempalaceGuidance(resolved.hooks, "refresher"),
   ];
-  if (resolved.hooks.searchGuidance) {
-    lines.push(
-      "- You **MUST** call `mempalace(action=\"search\", query=...)` before answering past-fact questions; per-turn search results appear below when relevant.",
-    );
-  }
   return lines.join("\n");
 }
 
@@ -326,7 +320,8 @@ export function registerMempalaceHooks(
     const wakeUpEnabled = config.mempalace.hooks.wakeUp;
     const guidanceEnabled = config.mempalace.hooks.searchGuidance;
     const autoSearchEnabled = config.mempalace.hooks.autoSearchOnPrompt;
-    if (!wakeUpEnabled && !guidanceEnabled && !autoSearchEnabled) return undefined;
+    const writeGuidanceEnabled = config.mempalace.hooks.writeGuidance;
+    if (!wakeUpEnabled && !guidanceEnabled && !writeGuidanceEnabled && !autoSearchEnabled) return undefined;
 
     const cwd = contextCwd(ctx);
     const resolved = resolveMempalaceConfig(config, cwd, platform.paths);

package/src/mempalace/tool.ts

@@ -15,6 +15,7 @@ import {
   snapshotMempalaceInstall,
   type MempalaceInstallSnapshot,
 } from "./installer-helper.js";
+import { MEMPALACE_TOOL_DESCRIPTION } from "./contract.js";
 
 export interface MempalaceToolDeps {
   createBridge?: (config: ResolvedMempalaceConfig, cwd: string) => MempalaceBridgeFacade;
@@ -130,8 +131,7 @@ export function registerMempalaceTool(
   platform.registerTool({
     name: "mempalace",
     label: "MemPalace",
-    description:
-      "MemPalace memory dispatcher. **MUST** call `search` before answering past-fact questions; write only on explicit user request.",
+    description: MEMPALACE_TOOL_DESCRIPTION,
     parameters: mempalaceToolParameters,
     async execute(_toolCallId: string, rawParams: unknown, _signal: AbortSignal, onUpdate: unknown, toolCtx: unknown) {
       try {

package/src/mempalace/uv.ts

@@ -12,6 +12,10 @@ export const PINNED_UV_VERSION = "0.5.30";
 
 const UV_BASE_URL = "https://github.com/astral-sh/uv/releases/download";
 
+const TAR_PREFLIGHT_TIMEOUT_MS = 3_000;
+const TAR_REMEDIATION =
+  "Install GNU tar / BSD tar (built-in on macOS, Linux, and Windows 10+). On older Windows, install Git for Windows or run `/supi:memory setup` after adding tar to PATH.";
+
 export type UvPlatform =
   | "darwin-arm64"
   | "darwin-x64"
@@ -118,6 +122,34 @@ function writeVersionStamp(managedBinDir: string, version: string): void {
   fs.writeFileSync(versionStampPath(managedBinDir), `${version}\n`, "utf8");
 }
 
+function tarUnavailable(message: string): EnsureUvResult {
+  return {
+    ok: false,
+    error: {
+      code: "uv_extract_failed",
+      message,
+      remediation: TAR_REMEDIATION,
+    },
+  };
+}
+
+async function verifyTarAvailable(runner: ProcessRunner): Promise<EnsureUvResult | null> {
+  let result;
+  try {
+    result = await runner("tar", ["--version"], { timeoutMs: TAR_PREFLIGHT_TIMEOUT_MS });
+  } catch (error) {
+    return tarUnavailable(
+      `tar is required to extract the uv archive but could not be launched: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+
+  if (result.code !== 0) {
+    return tarUnavailable("tar is required to extract the uv archive but is not on PATH.");
+  }
+
+  return null;
+}
+
 export async function ensureUv(options: EnsureUvOptions): Promise<EnsureUvResult> {
   const version = options.version ?? PINNED_UV_VERSION;
   const uvPlatform = options.platform === undefined ? detectUvPlatform() : options.platform;
@@ -139,6 +171,9 @@ export async function ensureUv(options: EnsureUvOptions): Promise<EnsureUvResult
     return { ok: true, uvPath: managedPath, version, source: "cached" };
   }
 
+  const tarPreflight = await verifyTarAvailable(options.runner);
+  if (tarPreflight) return tarPreflight;
+
   const fetcher = options.fetcher ?? defaultFetcher;
   options.onProgress?.(`Downloading uv ${version} for ${targetSpec.triple}`);
 
@@ -215,7 +250,7 @@ export async function ensureUv(options: EnsureUvOptions): Promise<EnsureUvResult
         message: `tar failed to extract uv archive (code ${extract.code}): ${
           extract.stderr.trim() || extract.stdout.trim() || "no output"
         }`,
-        remediation: "Ensure tar is on PATH (built-in on macOS, Linux, and Windows 10+).",
+        remediation: TAR_REMEDIATION,
       },
     };
   }

package/src/planning/planning-ask-tool.ts

@@ -129,11 +129,11 @@ function getAskRedirectReason(): string | null {
  */
 export function registerPlanningAskToolGuard(platform: Platform): void {
   platform.on("tool_call", (event) => {
-    if (event.toolName === "resolve" && isPlanApprovalResolveInput(event.input) && isPlanningActive()) {
+    if (event.toolName === "resolve" && isResolveApplyInput(event.input) && isPlanningActive()) {
       return {
         block: true,
         reason:
-          "Planning mode: /supi:plan uses a file-based approval hook. Do not call `resolve` with `extra.title` because it is OMP's native approval path and bypasses supipowers plan tracking.",
+          "Planning mode: /supi:plan uses a file-based approval hook. Native OMP plan approval is blocked because it bypasses supipowers plan tracking.",
       };
     }
 
@@ -149,13 +149,7 @@ export function registerPlanningAskToolGuard(platform: Platform): void {
   });
 }
 
-function isPlanApprovalResolveInput(input: unknown): boolean {
+function isResolveApplyInput(input: unknown): boolean {
   if (input === null || typeof input !== "object" || Array.isArray(input)) return false;
-  const candidate = input as { action?: unknown; extra?: unknown };
-  if (candidate.action !== "apply") return false;
-  const extra = candidate.extra;
-  return extra !== null
-    && typeof extra === "object"
-    && !Array.isArray(extra)
-    && typeof (extra as { title?: unknown }).title === "string";
+  return (input as { action?: unknown }).action === "apply";
 }

package/src/release/executor.ts

@@ -116,7 +116,8 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
     } else {
       console.log(`[dry-run] Would git tag -a ${tagName}`);
     }
-    console.log(`[dry-run] Would git push origin HEAD --follow-tags`);
+    console.log(`[dry-run] Would git push origin HEAD`);
+    console.log(`[dry-run] Would git push origin ${tagName}`);
     for (const channel of channels) {
       console.log(`[dry-run] Would publish to channel: ${channel}`);
     }
@@ -199,8 +200,8 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
 
   let pushAttempt = 0;
   while (true) {
-    progress("git-push", "active", pushAttempt === 0 ? "Pushing to origin" : "Retrying push after rebase");
-    const gitPush = await exec("git", ["push", "origin", "HEAD", "--follow-tags"], { cwd });
+    progress("git-push", "active", pushAttempt === 0 ? "Pushing commit to origin" : "Retrying commit push after rebase");
+    const gitPush = await exec("git", ["push", "origin", "HEAD"], { cwd });
     if (gitPush.code === 0) {
       progress("git-push", "done");
       break;
@@ -228,6 +229,15 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
     }
   }
 
+  progress("git-push-tags", "active", `Pushing ${tagName} to origin`);
+  const gitPushTag = await exec("git", ["push", "origin", tagName], { cwd });
+  if (gitPushTag.code !== 0) {
+    const detail = gitPushTag.stderr || gitPushTag.stdout || `exit code ${gitPushTag.code}`;
+    progress("git-push-tags", "error", detail);
+    return { version, tagCreated: true, pushed: false, channels: [], error: `git push tag: ${detail}` };
+  }
+  progress("git-push-tags", "done");
+
   const channelResults: ReleaseResult["channels"] = [];
   for (const channel of channels) {
     progress(`publish-${channel}`, "active", `Publishing to ${channel}`);

package/src/storage/plans.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { normalizeLineEndings } from "../text.js";
+import { ensureTrailingNewline, normalizeLineEndings } from "../text.js";
 import type { Plan, PlanTask, TaskComplexity, WorkspaceTarget } from "../types.js";
 import type { PlatformPaths } from "../platform/types.js";
 import { getProjectStatePath, getProjectTargetStatePath } from "../workspace/state-paths.js";
@@ -40,7 +40,7 @@ export function savePlan(paths: PlatformPaths, cwd: string, filename: string, co
   const dir = getPlansDir(paths, cwd);
   fs.mkdirSync(dir, { recursive: true });
   const filePath = path.join(dir, filename);
-  fs.writeFileSync(filePath, content);
+  fs.writeFileSync(filePath, ensureTrailingNewline(normalizeLineEndings(content)));
   return filePath;
 }
 

package/src/text.ts

@@ -1,6 +1,11 @@
-/** Normalizes Windows CRLF line endings to LF. */
+/** Normalizes CRLF and lone CR line endings to LF for deterministic artifacts. */
 export function normalizeLineEndings(text: string): string {
-  return text.replace(/\r\n/g, "\n");
+  return text.replace(/\r\n?/g, "\n");
+}
+
+/** Ensures text files have a trailing LF without changing already-terminated content. */
+export function ensureTrailingNewline(text: string): string {
+  return text.endsWith("\n") ? text : `${text}\n`;
 }
 
 /** Removes a single outer markdown code fence wrapper when present. */

package/src/types.ts

@@ -572,9 +572,11 @@ export interface MempalaceConfig {
   hooks: {
     wakeUp: boolean;
     searchGuidance: boolean;
+    writeGuidance: boolean;
     autoSearchOnPrompt: boolean;
     compactionCheckpoint: boolean;
     shutdownDiary: boolean;
+    postCommitReindex: boolean;
   };
   budgets: {
     wakeUpTokens: number;

package/src/utils/editor.ts

@@ -6,7 +6,7 @@ import type { Platform } from "../platform/types.js";
  * Resolution order:
  *  1. `$VISUAL`
  *  2. `$EDITOR`
- *  3. OS default opener (`open` on darwin, `start` on win32, `xdg-open` elsewhere)
+ *  3. OS default opener (`open` on darwin, `cmd /d /s /c start` on win32, `xdg-open` elsewhere)
  *
  * `platform.exec` blocks until the spawned editor process exits, which is what
  * the synthesize stage needs for its `$EDITOR` round-trip. For OS-default openers
@@ -18,7 +18,34 @@ import type { Platform } from "../platform/types.js";
  * without throwing. Callers that need to verify the user actually edited the file
  * should detect changes by comparing mtime / contents before and after.
  */
-export async function openInEditor(platform: Platform, filePath: string): Promise<void> {
+export interface EditorInvocation {
+  command: string;
+  args: string[];
+}
+
+
+function quoteCmdArgument(arg: string): string {
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+
+export function resolveDefaultEditorInvocation(
+  hostPlatform: NodeJS.Platform,
+  filePath: string,
+): EditorInvocation {
+  if (hostPlatform === "win32") {
+    return { command: "cmd", args: ["/d", "/s", "/c", `start "" ${quoteCmdArgument(filePath)}`] };
+  }
+
+  return hostPlatform === "darwin"
+    ? { command: "open", args: [filePath] }
+    : { command: "xdg-open", args: [filePath] };
+}
+
+export async function openInEditor(
+  platform: Platform,
+  filePath: string,
+  hostPlatform: NodeJS.Platform = process.platform,
+): Promise<void> {
   const editor = process.env.VISUAL || process.env.EDITOR;
   try {
     if (editor) {
@@ -28,9 +55,8 @@ export async function openInEditor(platform: Platform, filePath: string): Promis
       const args = [...tokens.slice(1), filePath];
       await platform.exec(cmd, args);
     } else {
-      const cmd = process.platform === "darwin" ? "open"
-        : process.platform === "win32" ? "start" : "xdg-open";
-      await platform.exec(cmd, [filePath]);
+      const invocation = resolveDefaultEditorInvocation(hostPlatform, filePath);
+      await platform.exec(invocation.command, invocation.args);
     }
   } catch {
     // Editor open failed — non-fatal, file was still written

package/src/visual/scripts/npm-shrinkwrap.json

@@ -10,7 +10,7 @@
       "dependencies": {
         "chokidar": "^4.0.0",
         "express": "^4.21.0",
-        "ws": "^8.18.0"
+        "ws": "^8.20.1"
       }
     },
     "node_modules/accepts": {
@@ -854,9 +854,9 @@
       }
     },
     "node_modules/ws": {
-      "version": "8.20.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
-      "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
+      "version": "8.20.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.1.tgz",
+      "integrity": "sha512-It4dO0K5v//JtTXuPkfEOaI3uUN87iYPnqo/ZzqCoG3g8uhA66QUMs/SrM0YK7/NAu+r4LMh/9dq2A7k+rHs+w==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"

package/src/visual/scripts/package-lock.json

@@ -10,7 +10,7 @@
       "dependencies": {
         "chokidar": "^4.0.0",
         "express": "^4.21.0",
-        "ws": "^8.18.0"
+        "ws": "^8.20.1"
       }
     },
     "node_modules/accepts": {
@@ -854,9 +854,9 @@
       }
     },
     "node_modules/ws": {
-      "version": "8.20.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.0.tgz",
-      "integrity": "sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==",
+      "version": "8.20.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.1.tgz",
+      "integrity": "sha512-It4dO0K5v//JtTXuPkfEOaI3uUN87iYPnqo/ZzqCoG3g8uhA66QUMs/SrM0YK7/NAu+r4LMh/9dq2A7k+rHs+w==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"

package/src/visual/scripts/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "dependencies": {
     "express": "^4.21.0",
-    "ws": "^8.18.0",
+    "ws": "^8.20.1",
     "chokidar": "^4.0.0"
   },
   "overrides": {