@ilya-lesikov/pi-pi 0.4.0 → 0.6.0

package/extensions/orchestrator/command-handlers.ts

@@ -1,17 +1,27 @@
 import { unregisterAgentDefinitions } from "./agents/registry.js";
-import { runAfterImplement } from "./commands.js";
+import { loadRepoAfterImplementCommands, runAfterImplement } from "./commands.js";
+import { resolvePreset } from "./config.js";
 import { nextPhase, validateExitCriteria } from "./phases/machine.js";
 import { spawnPlanners } from "./phases/planning.js";
 import { Orchestrator } from "./orchestrator.js";
-import { saveTask } from "./state.js";
+import { groupFilesByRepo } from "./repo-utils.js";
+import { getEffectiveMode, saveTask } from "./state.js";
+import { getLogger } from "./log.js";
+import { handleSpawnResult } from "./spawn-cleanup.js";
+
+function isEnabled(value: { enabled?: boolean }): boolean {
+  return value.enabled !== false;
+}
 
 export async function transitionToNextPhase(
   orchestrator: Orchestrator,
   ctx: any,
+  plannerPreset?: string,
 ): Promise<{ ok: boolean; error?: string }> {
   if (!orchestrator.active) return { ok: false, error: "No active task." };
-
+  const log = getLogger();
   const currentPhase = orchestrator.active.state.phase;
+  log.info({ s: "phase", from: currentPhase, plannerPreset: plannerPreset ?? null }, "transition requested");
   if (currentPhase === "done") return { ok: false, error: "Task is already done." };
 
   const exitCheck = validateExitCriteria(orchestrator.active.dir, orchestrator.active.type, currentPhase);
@@ -30,7 +40,26 @@ export async function transitionToNextPhase(
   if (!next) return { ok: false, error: "No next phase available." };
 
   if (currentPhase === "implement") {
-    const afterResults = runAfterImplement(orchestrator.config, orchestrator.cwd);
+    const repos = orchestrator.active.state.repos ?? [];
+    const grouped = groupFilesByRepo(repos, [...orchestrator.active.modifiedFiles]);
+    const afterResults: Array<{ ok: boolean; command: string; output: string }> = [];
+    for (const [repoPath] of grouped) {
+      if (!repoPath) continue;
+      const repo = repos.find((r) => r.path === repoPath);
+      if (!repo) continue;
+      if (repo.isRoot) {
+        afterResults.push(...runAfterImplement(
+          orchestrator.config.commands.afterImplement,
+          orchestrator.config.performance.commands.afterImplement,
+          orchestrator.cwd,
+        ));
+        continue;
+      }
+      if (!orchestrator.config.general.loadExtraRepoConfigs) continue;
+      const extraCommands = loadRepoAfterImplementCommands(repoPath);
+      if (!extraCommands || Object.keys(extraCommands).length === 0) continue;
+      afterResults.push(...runAfterImplement(extraCommands, orchestrator.config.performance.commands.afterImplement, repoPath));
+    }
     const failures = afterResults.filter((r) => !r.ok);
     if (failures.length > 0) {
       const failureText = failures.map((f) => `${f.command}: ${f.output}`).join("\n");
@@ -39,13 +68,17 @@ export async function transitionToNextPhase(
   }
 
   orchestrator.active.state.phase = next;
-  if (next !== "done") {
-    orchestrator.active.state.reviewCycle = null;
-    orchestrator.active.state.reviewPass = 0;
-    orchestrator.active.state.reviewPassByKind = {};
-    orchestrator.active.reviewPass = 0;
-  }
+  orchestrator.active.state.reviewCycle = null;
+  orchestrator.active.state.reviewPass = 0;
+  orchestrator.active.state.reviewApprovedClean = false;
+  orchestrator.active.reviewPass = 0;
   if (next === "plan") {
+    const autonomousPlannerPreset =
+      getEffectiveMode(orchestrator.active.state) === "autonomous"
+        ? orchestrator.active.state.autonomousConfig?.phases.plan?.plannerPreset
+        : undefined;
+    orchestrator.active.state.activePlannerPreset =
+      plannerPreset ?? autonomousPlannerPreset ?? orchestrator.config.agents.subagents.presetGroups.planners.default;
     orchestrator.active.state.step = "spawn_planners";
   } else if (next === "implement") {
     orchestrator.active.state.step = "llm_work";
@@ -59,49 +92,58 @@ export async function transitionToNextPhase(
   if (next === "done") {
     const name = orchestrator.active.description;
     const type = orchestrator.active.type;
-    orchestrator.taskDoneCompactionPending = true;
-    orchestrator.taskDoneCompactionSummary = `Task "${name}" (${type}) completed.`;
 
     orchestrator.abortAllSubagents();
     unregisterAgentDefinitions(orchestrator.pi);
     await orchestrator.cleanupActive();
     orchestrator.updateStatus(ctx);
-    ctx.compact();
+    orchestrator.lastCtx = ctx;
+    // Route the task-done compaction through the controller as a "done" target.
+    void orchestrator.transitionController.requestTransition({
+      kind: "done",
+      summary: `Task "${name}" (${type}) completed.`,
+    });
     ctx.ui.notify("Task completed!", "info");
     return { ok: true };
   }
 
   orchestrator.updateStatus(ctx);
+  const phaseSummary = `Phase "${currentPhase}" completed. Now entering "${next}" phase.`;
 
   if (next === "plan") {
     orchestrator.active.state.step = "await_planners";
     saveTask(orchestrator.active.dir, orchestrator.active.state);
   }
 
-  orchestrator.compactAndTransition(ctx, orchestrator.active.dir, orchestrator.active.state.phase);
-
-  if (next === "plan") {
-    orchestrator.pendingSubagentSpawns = Object.values(orchestrator.config.planners).filter((v) => v.enabled).length;
+  const onReady = next === "plan" ? () => {
+    if (!orchestrator.active) return;
+    const plannerVariants = resolvePreset(orchestrator.config, "planners", orchestrator.active.state.activePlannerPreset);
+    orchestrator.pendingSubagentSpawns = Object.values(plannerVariants).filter((v) => isEnabled(v)).length;
     orchestrator.failedPlannerVariants = [];
-    spawnPlanners(orchestrator.pi, orchestrator.cwd, orchestrator.active.dir, orchestrator.active.taskId, orchestrator.config).then((result) => {
-      orchestrator.failedPlannerVariants = result.failedVariants;
-      if (result.spawned === 0) orchestrator.pendingSubagentSpawns = 0;
-      for (const id of result.agentIds ?? []) {
-        orchestrator.spawnedAgentIds.delete(id);
-      }
-      orchestrator.pendingSubagentSpawns = 0;
-    }).catch((err) => {
-      orchestrator.pendingSubagentSpawns = 0;
-      console.error(`[pi-pi] spawnPlanners failed: ${err.message}`);
-    });
-  }
+    handleSpawnResult(
+      orchestrator,
+      spawnPlanners(
+        orchestrator.pi,
+        orchestrator.cwd,
+        orchestrator.active.dir,
+        orchestrator.active.taskId,
+        orchestrator.config,
+        orchestrator.transitionController.phaseSend,
+        plannerVariants,
+        orchestrator.active?.state.repos ?? [],
+      ),
+      { kind: "planner", logScope: "planner", logMessage: "spawnPlanners failed", onSettled: (result) => { if (!result?.spawned) orchestrator.checkPlannerCompletion(); } },
+    );
+  } : undefined;
+
+  orchestrator.compactAndTransition(ctx, orchestrator.active.dir, orchestrator.active.state.phase, onReady, phaseSummary);
 
   return { ok: true };
 }
 
 export function registerCommandHandlers(orchestrator: Orchestrator): void {
   const pi = orchestrator.pi;
-  orchestrator.transitionToNextPhase = (ctx: any) => transitionToNextPhase(orchestrator, ctx);
+  orchestrator.transitionToNextPhase = (ctx: any, plannerPreset?: string) => transitionToNextPhase(orchestrator, ctx, plannerPreset);
 
   pi.registerCommand("pp", {
     description: "Open pi-pi task menu",
@@ -109,7 +151,7 @@ export function registerCommandHandlers(orchestrator: Orchestrator): void {
       const { showPpMenu } = await import("./pp-menu.js");
       const text = await showPpMenu(orchestrator, ctx, "command");
       if (text) {
-        pi.sendUserMessage(`[PI-PI] ${text}`, { deliverAs: "followUp" });
+        orchestrator.safeSendUserMessage(`[PI-PI] ${text}`);
       }
     },
   });

package/extensions/orchestrator/commands.test.ts

@@ -1,9 +1,15 @@
-import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
 import { execFileSync } from "child_process";
 import { afterEach, describe, expect, it } from "vitest";
-import { autoCommit } from "./commands.js";
+import {
+  autoCommit,
+  loadRepoAfterEditCommands,
+  loadRepoAfterImplementCommands,
+  runAfterEdit,
+  runAfterImplement,
+} from "./commands.js";
 
 const tempDirs: string[] = [];
 
@@ -18,6 +24,12 @@ function makeRepo(): string {
   return cwd;
 }
 
+function makeDir(): string {
+  const cwd = mkdtempSync(join(tmpdir(), "pi-pi-commands-"));
+  tempDirs.push(cwd);
+  return cwd;
+}
+
 afterEach(() => {
   while (tempDirs.length > 0) {
     const dir = tempDirs.pop();
@@ -26,6 +38,14 @@ afterEach(() => {
 });
 
 describe("autoCommit", () => {
+  it("returns ok when there are no files", () => {
+    const cwd = makeRepo();
+
+    const result = autoCommit([], "ignored", cwd);
+
+    expect(result).toEqual({ ok: true });
+  });
+
   it("falls back to checkpoint when message is empty", () => {
     const cwd = makeRepo();
     const file = "a.ts";
@@ -40,6 +60,29 @@ describe("autoCommit", () => {
     expect(subject).toBe("checkpoint");
   });
 
+  it("extracts the commit hash on a normal branch", () => {
+    const cwd = makeRepo();
+    writeFileSync(join(cwd, "h.ts"), "export const h = 1;\n", "utf-8");
+
+    const result = autoCommit(["h.ts"], "first", cwd);
+
+    expect(result.ok).toBe(true);
+    expect(result.commitHash).toMatch(/^[a-f0-9]{7,}$/);
+  });
+
+  it("extracts the commit hash in detached HEAD state", () => {
+    const cwd = makeRepo();
+    writeFileSync(join(cwd, "base.ts"), "export const base = 1;\n", "utf-8");
+    autoCommit(["base.ts"], "base", cwd);
+    execFileSync("git", ["checkout", "--detach"], { cwd, stdio: "pipe" });
+
+    writeFileSync(join(cwd, "detached.ts"), "export const d = 1;\n", "utf-8");
+    const result = autoCommit(["detached.ts"], "on detached head", cwd);
+
+    expect(result.ok).toBe(true);
+    expect(result.commitHash).toMatch(/^[a-f0-9]{7,}$/);
+  });
+
   it("uses message as-is for commit", () => {
     const cwd = makeRepo();
     const file = "b.ts";
@@ -78,4 +121,214 @@ describe("autoCommit", () => {
     const committedFiles = execFileSync("git", ["show", "--name-only", "--pretty="], { cwd, encoding: "utf-8", stdio: "pipe" });
     expect(committedFiles.split("\n")).toContain(file);
   });
+
+  it("commits renamed files when new path is provided", () => {
+    const cwd = makeRepo();
+    writeFileSync(join(cwd, "old.ts"), "export const oldValue = 1;\n", "utf-8");
+    autoCommit(["old.ts"], "seed", cwd);
+
+    execFileSync("git", ["mv", "old.ts", "new.ts"], { cwd, stdio: "pipe" });
+
+    const result = autoCommit(["new.ts"], "rename old to new", cwd);
+
+    expect(result.ok).toBe(true);
+    const status = execFileSync("git", ["show", "--name-status", "--pretty="], { cwd, encoding: "utf-8", stdio: "pipe" });
+    expect(status).toContain("R100\told.ts\tnew.ts");
+  });
+
+  it("returns error when commit fails", () => {
+    const cwd = makeRepo();
+
+    const result = autoCommit(["missing.ts"], "should fail", cwd);
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toBeTruthy();
+  });
+});
+
+describe("runAfterEdit", () => {
+  it("runs commands only when glob matches", () => {
+    const cwd = makeDir();
+    const outFile = join(cwd, "out.txt");
+    const commands = {
+      "cmd-1": { run: `node -e "require('fs').appendFileSync(process.argv[1], 'ts\\n')" ${JSON.stringify(outFile)}`, globs: ["**/*.ts"] },
+      "cmd-2": { run: `node -e "require('fs').appendFileSync(process.argv[1], 'js\\n')" ${JSON.stringify(outFile)}`, globs: ["**/*.js"] },
+    };
+
+    const results = runAfterEdit("src/file.ts", commands, 5000, cwd);
+
+    expect(results).toHaveLength(1);
+    expect(results[0]?.ok).toBe(true);
+    expect(results[0]?.command).toContain("appendFileSync");
+    const out = execFileSync("node", ["-e", `process.stdout.write(require('fs').readFileSync(${JSON.stringify(outFile)}, 'utf-8'))`], { encoding: "utf-8" });
+    expect(out).toBe("ts\n");
+  });
+
+  it("substitutes file and dir variables", () => {
+    const cwd = makeDir();
+    const commands = {
+      "cmd-1": { run: "node -e \"process.stdout.write(process.argv.slice(1).join('|'))\" ${file} ${dir}", globs: ["**/*.ts"] },
+    };
+
+    const results = runAfterEdit("src/nested/file.ts", commands, 5000, cwd);
+
+    expect(results).toHaveLength(1);
+    expect(results[0]?.ok).toBe(true);
+    expect(results[0]?.output).toBe("src/nested/file.ts|src/nested");
+  });
+
+  it("returns failure result on timeout", () => {
+    const cwd = makeDir();
+    const commands = { "cmd-1": { run: "node -e \"setTimeout(() => {}, 200)\"", globs: ["**/*.ts"] } };
+
+    const results = runAfterEdit("src/slow.ts", commands, 20, cwd);
+
+    expect(results).toHaveLength(1);
+    expect(results[0]?.ok).toBe(false);
+    expect(results[0]?.output.length).toBeGreaterThan(0);
+  });
+
+  it("propagates stderr output on failure", () => {
+    const cwd = makeDir();
+    const commands = { "cmd-1": { run: "node -e \"process.stderr.write('boom'); process.exit(2)\"", globs: ["**/*.ts"] } };
+
+    const results = runAfterEdit("src/fail.ts", commands, 5000, cwd);
+
+    expect(results).toHaveLength(1);
+    expect(results[0]?.ok).toBe(false);
+    expect(results[0]?.output).toContain("boom");
+  });
+
+  it("returns mixed results when some commands fail", () => {
+    const cwd = makeDir();
+    const commands = {
+      "cmd-1": { run: "node -e \"process.stdout.write('ok1')\"", globs: ["**/*.ts"] },
+      "cmd-2": { run: "node -e \"process.stderr.write('nope'); process.exit(1)\"", globs: ["**/*.ts"] },
+      "cmd-3": { run: "node -e \"process.stdout.write('ok2')\"", globs: ["**/*.ts"] },
+    };
+
+    const results = runAfterEdit("src/mixed.ts", commands, 5000, cwd);
+
+    expect(results).toHaveLength(3);
+    expect(results.map((r) => r.ok)).toEqual([true, false, true]);
+    expect(results[1]?.output).toContain("nope");
+  });
+});
+
+describe("runAfterImplement", () => {
+  it("runs commands and captures output", () => {
+    const cwd = makeDir();
+
+    const results = runAfterImplement({ "cmd-1": { run: "node -e \"process.stdout.write('done')\"" } }, 5000, cwd);
+
+    expect(results).toEqual([{ ok: true, command: "node -e \"process.stdout.write('done')\"", output: "done" }]);
+  });
+
+  it("propagates failure output", () => {
+    const cwd = makeDir();
+
+    const results = runAfterImplement({ "cmd-1": { run: "node -e \"process.stderr.write('broken'); process.exit(1)\"" } }, 5000, cwd);
+
+    expect(results).toHaveLength(1);
+    expect(results[0]?.ok).toBe(false);
+    expect(results[0]?.output).toContain("broken");
+  });
+});
+
+describe("loadRepoAfterEditCommands", () => {
+  it("loads commands from repo .pp/config.json", () => {
+    const cwd = makeDir();
+    mkdirSync(join(cwd, ".pp"), { recursive: true });
+    writeFileSync(
+      join(cwd, ".pp", "config.json"),
+      JSON.stringify({ commands: { afterEdit: { "cmd-1": { run: "npm test", globs: ["**/*.ts"] } } } }),
+      "utf-8",
+    );
+
+    const commands = loadRepoAfterEditCommands(cwd);
+
+    expect(commands).toEqual({ "cmd-1": { run: "npm test", globs: ["**/*.ts"] } });
+  });
+
+  it("returns null when config is missing", () => {
+    const cwd = makeDir();
+
+    const commands = loadRepoAfterEditCommands(cwd);
+
+    expect(commands).toBeNull();
+  });
+
+  it("filters invalid entries", () => {
+    const cwd = makeDir();
+    mkdirSync(join(cwd, ".pp"), { recursive: true });
+    writeFileSync(
+      join(cwd, ".pp", "config.json"),
+      JSON.stringify({
+        commands: {
+          afterEdit: {
+            badNull: null,
+            badEmpty: { run: "" },
+            badType: { run: 1 },
+            validOne: { run: "valid-one", globs: ["**/*.ts", 1, null] },
+            validTwo: { run: "valid-two" },
+          },
+        },
+      }),
+      "utf-8",
+    );
+
+    const commands = loadRepoAfterEditCommands(cwd);
+
+    expect(commands).toEqual({
+      validOne: { run: "valid-one", globs: ["**/*.ts"] },
+      validTwo: { run: "valid-two" },
+    });
+  });
+});
+
+describe("loadRepoAfterImplementCommands", () => {
+  it("loads commands from repo .pp/config.json", () => {
+    const cwd = makeDir();
+    mkdirSync(join(cwd, ".pp"), { recursive: true });
+    writeFileSync(
+      join(cwd, ".pp", "config.json"),
+      JSON.stringify({ commands: { afterImplement: { "cmd-1": { run: "npm run check" } } } }),
+      "utf-8",
+    );
+
+    const commands = loadRepoAfterImplementCommands(cwd);
+
+    expect(commands).toEqual({ "cmd-1": { run: "npm run check" } });
+  });
+
+  it("returns null when config is missing", () => {
+    const cwd = makeDir();
+
+    const commands = loadRepoAfterImplementCommands(cwd);
+
+    expect(commands).toBeNull();
+  });
+
+  it("filters invalid entries", () => {
+    const cwd = makeDir();
+    mkdirSync(join(cwd, ".pp"), { recursive: true });
+    writeFileSync(
+      join(cwd, ".pp", "config.json"),
+      JSON.stringify({
+        commands: {
+          afterImplement: {
+            badNull: null,
+            badEmpty: { run: "" },
+            badType: { run: 1 },
+            valid: { run: "valid" },
+          },
+        },
+      }),
+      "utf-8",
+    );
+
+    const commands = loadRepoAfterImplementCommands(cwd);
+
+    expect(commands).toEqual({ valid: { run: "valid" } });
+  });
 });

package/extensions/orchestrator/commands.ts

@@ -1,7 +1,8 @@
 import { execSync, execFileSync } from "child_process";
-import { dirname } from "path";
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
 import { minimatch } from "minimatch";
-import type { PiPiConfig, AfterEditCommand } from "./config.js";
+import type { AfterEditCommandConfig, AfterImplementCommandConfig } from "./config.js";
 
 interface CommandResult {
   ok: boolean;
@@ -9,6 +10,10 @@ interface CommandResult {
   output: string;
 }
 
+function isEnabled(command: { enabled?: boolean }): boolean {
+  return command.enabled !== false;
+}
+
 function shellEscape(arg: string): string {
   return "'" + arg.replace(/'/g, "'\\''") + "'";
 }
@@ -22,12 +27,18 @@ function substituteVars(command: string, file?: string): string {
   return result;
 }
 
-export function runAfterEdit(file: string, config: PiPiConfig, cwd: string): CommandResult[] {
+export function runAfterEdit(
+  file: string,
+  commands: Record<string, AfterEditCommandConfig>,
+  timeout: number,
+  cwd: string,
+): CommandResult[] {
   const results: CommandResult[] = [];
-  const timeout = config.timeouts.afterEdit;
 
-  for (const cmd of config.commands.afterEdit) {
-    const matches = !cmd.glob || cmd.glob.length === 0 || cmd.glob.some((g) => minimatch(file, g, { matchBase: true }));
+  for (const cmd of Object.values(commands)) {
+    if (!isEnabled(cmd)) continue;
+    const globs = cmd.globs ?? [];
+    const matches = globs.length === 0 || globs.some((g) => minimatch(file, g, { matchBase: true }));
     if (!matches) continue;
 
     const command = substituteVars(cmd.run, file);
@@ -42,11 +53,20 @@ export function runAfterEdit(file: string, config: PiPiConfig, cwd: string): Com
   return results;
 }
 
-export function runAfterImplement(config: PiPiConfig, cwd: string): CommandResult[] {
+// Executes shell commands from config via execSync. For the root repo these come
+// from the user's own .pp/config.json; for sub-repos they are loaded only when
+// general.loadExtraRepoConfigs is explicitly enabled (off by default), so running
+// them is a deliberate, opt-in trust decision in the same security domain as the
+// repos the user registered.
+export function runAfterImplement(
+  commands: Record<string, AfterImplementCommandConfig>,
+  timeout: number,
+  cwd: string,
+): CommandResult[] {
   const results: CommandResult[] = [];
-  const timeout = config.timeouts.afterImplement;
 
-  for (const cmd of config.commands.afterImplement) {
+  for (const cmd of Object.values(commands)) {
+    if (!isEnabled(cmd)) continue;
     const command = substituteVars(cmd.run);
     try {
       const output = execSync(command, { cwd, encoding: "utf-8", timeout, stdio: "pipe" });
@@ -59,6 +79,84 @@ export function runAfterImplement(config: PiPiConfig, cwd: string): CommandResul
   return results;
 }
 
+function loadRepoConfig(repoPath: string): Record<string, any> | null {
+  const configPath = join(repoPath, ".pp", "config.json");
+  if (!existsSync(configPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+    return raw && typeof raw === "object" ? raw : null;
+  } catch {
+    return null;
+  }
+}
+
+export function loadRepoAfterEditCommands(repoPath: string): Record<string, AfterEditCommandConfig> | null {
+  const raw = loadRepoConfig(repoPath);
+  if (!raw) return null;
+  const commands = raw?.commands?.afterEdit;
+  if (!commands || typeof commands !== "object") return null;
+
+  if (Array.isArray(commands)) {
+    const valid: Record<string, AfterEditCommandConfig> = {};
+    for (const [index, cmd] of commands.entries()) {
+      if (!cmd || typeof cmd !== "object") continue;
+      const run = (cmd as any).run;
+      if (typeof run !== "string" || run.length === 0) continue;
+      const globsRaw = (cmd as any).globs ?? (cmd as any).glob;
+      const globs = Array.isArray(globsRaw) ? globsRaw.filter((g): g is string => typeof g === "string") : undefined;
+      valid[`cmd-${index + 1}`] = { run, ...(globs && globs.length > 0 ? { globs } : {}) };
+    }
+    return Object.keys(valid).length > 0 ? valid : null;
+  }
+
+  const valid: Record<string, AfterEditCommandConfig> = {};
+  for (const [id, cmd] of Object.entries(commands as Record<string, unknown>)) {
+    if (!cmd || typeof cmd !== "object") continue;
+    const run = (cmd as any).run;
+    if (typeof run !== "string" || run.length === 0) continue;
+    const enabledRaw = (cmd as any).enabled;
+    const globsRaw = (cmd as any).globs ?? (cmd as any).glob;
+    const globs = Array.isArray(globsRaw) ? globsRaw.filter((g): g is string => typeof g === "string") : undefined;
+    valid[id] = {
+      run,
+      ...(globs && globs.length > 0 ? { globs } : {}),
+      ...(typeof enabledRaw === "boolean" ? { enabled: enabledRaw } : {}),
+    };
+  }
+  return valid;
+}
+
+export function loadRepoAfterImplementCommands(repoPath: string): Record<string, AfterImplementCommandConfig> | null {
+  const raw = loadRepoConfig(repoPath);
+  if (!raw) return null;
+  const commands = raw?.commands?.afterImplement;
+  if (!commands || typeof commands !== "object") return null;
+
+  if (Array.isArray(commands)) {
+    const valid: Record<string, AfterImplementCommandConfig> = {};
+    for (const [index, cmd] of commands.entries()) {
+      if (!cmd || typeof cmd !== "object") continue;
+      const run = (cmd as any).run;
+      if (typeof run !== "string" || run.length === 0) continue;
+      valid[`cmd-${index + 1}`] = { run };
+    }
+    return Object.keys(valid).length > 0 ? valid : null;
+  }
+
+  const valid: Record<string, AfterImplementCommandConfig> = {};
+  for (const [id, cmd] of Object.entries(commands as Record<string, unknown>)) {
+    if (!cmd || typeof cmd !== "object") continue;
+    const run = (cmd as any).run;
+    if (typeof run !== "string" || run.length === 0) continue;
+    const enabledRaw = (cmd as any).enabled;
+    valid[id] = {
+      run,
+      ...(typeof enabledRaw === "boolean" ? { enabled: enabledRaw } : {}),
+    };
+  }
+  return valid;
+}
+
 export function autoCommit(files: string[], message: string, cwd: string): { ok: boolean; commitHash?: string; error?: string } {
   if (files.length === 0) return { ok: true };
 
@@ -67,7 +165,7 @@ export function autoCommit(files: string[], message: string, cwd: string): { ok:
   try {
     execFileSync("git", ["add", "--", ...files], { cwd, encoding: "utf-8", stdio: "pipe" });
     const output =     execFileSync("git", ["commit", "-m", cleanMessage], { cwd, encoding: "utf-8", stdio: "pipe" });
-    const hashMatch = output.match(/\[[\w-]+ (?:\([^)]+\) )?([a-f0-9]+)\]/);
+    const hashMatch = output.match(/\[[^\]]* ([a-f0-9]{7,40})\]/);
     return { ok: true, commitHash: hashMatch?.[1] };
   } catch (err: any) {
     return { ok: false, error: err.stderr?.toString() || err.message };