Stop refusing work when a folder is not a git repository

Required style skill told models to refuse if cwd had no .git. Eval fixtures are tmp copies, so GPT stopped on simple-health. Edits are allowed without a repo; eval workdirs get an unsigned fixture commit so isolated workers have HEAD.

Author: TheGreatAxios

CHANGELOG.md

@@ -75,9 +75,17 @@ parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
   closed directors — the operator types the slash; the primary does not
   do the work. Turn the catalog off in `/plugins` if you want those
   commands gone.
+- **Style skill no longer refuses non-git folders.** Edits, tests, and
+  reports are allowed without a repository. Do not `git init` unless
+  asked. Commits, amends, rebases, and isolated worktree dispatch still
+  require an existing repo.
 
 ### Evals
 
+- **Capability eval workdirs are git repos.** After copying the fixture
+  and seeding skill stubs, the runner initializes the tmp workdir (`git
+  init`, `git add -A`, one unsigned hermetic `eval fixture` commit) so isolated
+  workers have HEAD and git-aware skills have a baseline.
 - **Eval runners require an explicit model pair.** `eval:capability` and
   `eval:public-swe-one` take `--provider` / `--model` (capability also
   accepts `--matrix` with complete cells) so local `.corbits/settings.json`

evals/capability/README.md

@@ -8,6 +8,8 @@ Local, multi-model capability checks against the **product** agent path (`corbit
 
 Whether a real model + our directors/tools can complete small coding tasks on fixture repos. Graders are objective shell scripts (`verify.sh`) — pass/fail, not LLM-as-judge.
 
+Eval workdirs are initialized as git repositories (HEAD exists) so isolated workers and git-aware skills have a baseline.
+
 One run can **try different things**: multiple cases × multiple provider/model variants (matrix), with every product-path metric we can record written into the results JSON.
 
 | Tier | Case | Fixture | Intent |

plugins/corbits-skills/skills/style/SKILL.md

@@ -10,12 +10,13 @@ General guidelines for writing clean, maintainable code.
 
 ## Git Repository Requirement
 
-Agents must only operate within git repositories. Before performing any work:
+Prefer a git repository so changes can be tracked, reviewed, and reverted.
 
-1. Verify the current working directory is inside a git repository
-2. If not in a git repository, refuse to proceed
+Edits, tests, and reports are allowed in a folder that is not a git repository. Do not refuse the task.
 
-Without a git repository, it's too hard to succeed with agents - changes can't be tracked, reviewed, or safely reverted.
+Do not `git init` unless the user asked you to create a repository.
+
+Commits, amends, rebases, and isolated worktree dispatch require an existing git repository. If the user asked to commit and there is no repository, say so and stop — do not invent a repository.
 
 ## Documentation
 

scripts/eval-capability.test.ts

@@ -1,6 +1,13 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 
-import { parseArgs } from "./eval-capability.ts";
+import { initEvalGitRepo, parseArgs } from "./eval-capability.ts";
+
+const execFileAsync = promisify(execFile);
 
 describe("parseArgs", () => {
   test("--help does not require provider or model", () => {
@@ -55,3 +62,67 @@ describe("parseArgs", () => {
     expect(pair.model).toBe("bar");
   });
 });
+
+describe("initEvalGitRepo", () => {
+  const savedGitConfigGlobal = process.env.GIT_CONFIG_GLOBAL;
+
+  const restoreGitConfigGlobal = (): void => {
+    if (savedGitConfigGlobal === undefined) {
+      delete process.env.GIT_CONFIG_GLOBAL;
+    } else {
+      process.env.GIT_CONFIG_GLOBAL = savedGitConfigGlobal;
+    }
+  };
+
+  afterEach(() => {
+    restoreGitConfigGlobal();
+  });
+
+  test("makes a fixture copy a git work tree with a commit", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "corbits-eval-git-"));
+    try {
+      await writeFile(join(dir, "README"), "fixture\n", "utf8");
+      await initEvalGitRepo(dir);
+      const { stdout } = await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], {
+        cwd: dir,
+      });
+      expect(stdout.trim()).toBe("true");
+      const { stdout: head } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: dir });
+      expect(head.trim().length).toBeGreaterThan(0);
+      const { stdout: count } = await execFileAsync("git", ["rev-list", "--count", "HEAD"], {
+        cwd: dir,
+      });
+      expect(Number(count.trim())).toBeGreaterThanOrEqual(1);
+      const { stdout: log } = await execFileAsync("git", ["log", "-1", "--pretty=%s"], {
+        cwd: dir,
+      });
+      expect(log.trim()).toBe("eval fixture");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("succeeds when the process would otherwise sign", async () => {
+    const root = await mkdtemp(join(tmpdir(), "corbits-eval-git-sign-"));
+    const work = join(root, "work");
+    const configPath = join(root, "gitconfig");
+    try {
+      await mkdir(work);
+      await writeFile(
+        configPath,
+        "[commit]\ngpgsign = true\n[user]\nsigningkey = DEADKEY\n",
+        "utf8",
+      );
+      process.env.GIT_CONFIG_GLOBAL = configPath;
+      await writeFile(join(work, "README"), "fixture\n", "utf8");
+      await initEvalGitRepo(work);
+      const { stdout: head } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: work });
+      expect(head.trim().length).toBeGreaterThan(0);
+      const { stdout: cat } = await execFileAsync("git", ["cat-file", "-p", "HEAD"], { cwd: work });
+      expect(cat).not.toContain("gpgsig");
+    } finally {
+      restoreGitConfigGlobal();
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});

scripts/eval-capability.ts

@@ -312,13 +312,46 @@ async function seedEvalSkillStubs(workdir: string): Promise<void> {
   }
 }
 
+/**
+ * Initialize a git repo in an eval tmp workdir so isolated workers have HEAD
+ * and git-aware skills have a baseline. Identity is `git -c`, never env or
+ * global config. The fixture commit is unsigned (`--no-gpg-sign`,
+ * `-c commit.gpgsign=false`) and skips hooks (`--no-verify`) so operator
+ * `commit.gpgsign` / `core.hooksPath` cannot fail or sign with the operator
+ * key. Do not call this on source fixtures.
+ */
+export async function initEvalGitRepo(workdir: string): Promise<void> {
+  const identity = ["-c", "user.email=eval@local", "-c", "user.name=eval"] as const;
+  const git = async (args: readonly string[]): Promise<void> => {
+    const result = await runCommand("git", args, workdir, 30_000);
+    if (result.exitCode !== 0) {
+      throw new Error(
+        `git ${args.join(" ")} failed (${result.exitCode}): ${result.stderr || result.stdout}`,
+      );
+    }
+  };
+  await git(["init"]);
+  await git([...identity, "add", "-A"]);
+  await git([
+    ...identity,
+    "-c",
+    "commit.gpgsign=false",
+    "commit",
+    "--no-gpg-sign",
+    "--no-verify",
+    "-m",
+    "eval fixture",
+  ]);
+}
+
 async function prepareWorkdir(caseDef: EvalCase): Promise<{ workdir: string; capturePath: string }> {
   const fixtureAbs = resolveFixturePath(REPO_ROOT, caseDef.fixture);
   const work = await mkdtemp(join(tmpdir(), `corbits-eval-${caseDef.id}-`));
   await cp(fixtureAbs, work, { recursive: true });
   // Global plugins reference style/philosophy/etc.; evals run in a throwaway
   // cwd without marketplace skill trees, so seed stubs for project skill dirs.
   await seedEvalSkillStubs(work);
+  await initEvalGitRepo(work);
   // Sibling of the workdir so the agent and verify.sh never see the capture.
   const capturePath = `${work}-run-summary.json`;
   await installRunCaptureHook(work, capturePath);