gentle-pi 2.7.0 → 3.0.0

package/scripts/verify-package-files.mjs

@@ -34,7 +34,6 @@ const requiredPaths = [
   "assets/agents/sdd-research.md",
   "assets/agents/sdd-spec.md",
   "assets/agents/sdd-status.md",
-  "assets/agents/sdd-sync.md",
   "assets/agents/sdd-tasks.md",
   "assets/agents/sdd-verify.md",
   "assets/chains/4r-review.chain.md",

package/tests/agent-home.test.ts

@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { gentlePiConfigHome } from "../lib/agent-home.ts";
+
+// The two Pi homes: `~/.pi/agent` holds Pi's own agent definitions and
+// `~/.pi/gentle-ai` holds everything the Gentle AI commands own. Both are resolved
+// once and shared, because the launch-time profile pin resolver reads the same
+// profiles store the `/gentle:profiles` panel writes: two spellings of the override
+// would silently read two different stores.
+
+function isolatedHome(t: test.TestContext): string {
+	const home = mkdtempSync(join(tmpdir(), "gentle-pi-config-home-"));
+	const previousHome = process.env.HOME;
+	const previousUserProfile = process.env.USERPROFILE;
+	// Isolation must cover POSIX and Windows, the way homedir() resolves each.
+	process.env.HOME = home;
+	process.env.USERPROFILE = home;
+	t.after(() => {
+		if (previousHome === undefined) delete process.env.HOME;
+		else process.env.HOME = previousHome;
+		if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = previousUserProfile;
+		rmSync(home, { recursive: true, force: true });
+	});
+	return home;
+}
+
+test("gentlePiConfigHome honours GENTLE_PI_CONFIG_HOME and otherwise falls back to ~/.pi/gentle-ai", (t) => {
+	const home = isolatedHome(t);
+	assert.equal(gentlePiConfigHome({ GENTLE_PI_CONFIG_HOME: "/custom/gentle-ai" }), "/custom/gentle-ai");
+	assert.equal(gentlePiConfigHome({ GENTLE_PI_CONFIG_HOME: "" }), join(homedir(), ".pi", "gentle-ai"));
+	assert.equal(gentlePiConfigHome({}), join(homedir(), ".pi", "gentle-ai"));
+	assert.equal(gentlePiConfigHome(), join(homedir(), ".pi", "gentle-ai"));
+	assert.equal(
+		join(gentlePiConfigHome(), "profiles.json"),
+		join(home, ".pi", "gentle-ai", "profiles.json"),
+		"the store path is derived from the config home, not from the agent home",
+	);
+});
+
+test("the config home ignores the Pi agent-home overrides", (t) => {
+	const home = isolatedHome(t);
+	// PI_CODING_AGENT_DIR and GENTLE_PI_AGENT_HOME move Pi's agent directory only.
+	// Reusing that resolver here would point the profiles store at the agent home.
+	assert.equal(
+		gentlePiConfigHome({ PI_CODING_AGENT_DIR: "/pi/agent", GENTLE_PI_AGENT_HOME: "/gentle/agent" }),
+		join(home, ".pi", "gentle-ai"),
+	);
+});

package/tests/agent-profiles.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test, { after } from "node:test";
@@ -37,6 +37,7 @@ import {
 	setActiveProfile,
 	summarizeProfile,
 	updateProfile,
+	writeJsonFileAtomicallySync,
 	writeProfilesFileSync,
 } from "../lib/agent-profiles.ts";
 import type { AgentModelConfig } from "../lib/model-routing-authority.ts";
@@ -623,6 +624,34 @@ test("writeProfilesFileSync creates missing parent directories", () => {
 	assert.equal(readProfilesFileResult(path).status, "valid");
 });
 
+// The profiles store and the per-repository profile pin both replace their file
+// through this helper, so the interruption guarantee belongs to the helper and not
+// to one store's serializer.
+test("writeJsonFileAtomicallySync writes exact bytes, creates parents, and leaves no temp file behind", () => {
+	const path = join(root, "atomic-text", "artifact.json");
+	const first = `${JSON.stringify({ kind: "gentle-pi.test", value: 1 }, null, 2)}\n`;
+	writeJsonFileAtomicallySync(path, first);
+	assert.equal(readFileSync(path, "utf8"), first);
+	writeJsonFileAtomicallySync(path, "second\n");
+	assert.equal(readFileSync(path, "utf8"), "second\n");
+	assert.deepEqual(readdirSync(join(root, "atomic-text")).filter((entry) => entry.includes(".tmp")), []);
+});
+
+test("writeJsonFileAtomicallySync skips an identical rewrite so the file is not replaced", () => {
+	const path = join(root, "atomic-noop", "artifact.json");
+	const text = `${JSON.stringify({ kind: "gentle-pi.test", value: 1 }, null, 2)}\n`;
+	writeJsonFileAtomicallySync(path, text);
+	const historicalTime = new Date("2000-01-01T00:00:00.000Z");
+	utimesSync(path, historicalTime, historicalTime);
+	const first = statSync(path).mtimeMs;
+	writeJsonFileAtomicallySync(path, text);
+	const skipped = statSync(path).mtimeMs;
+	assert.equal(readFileSync(path, "utf8"), text);
+	assert.equal(skipped, first, "an identical rewrite leaves the file untouched");
+	writeJsonFileAtomicallySync(path, "changed\n");
+	assert.notEqual(statSync(path).mtimeMs, skipped, "a changed rewrite still replaces the file");
+});
+
 test("writeProfilesFileSync replaces the store and leaves no temp file behind", () => {
 	const path = join(root, "atomic.json");
 	const first = createProfile(emptyProfilesFile(), "alpha", CONFIG);

package/tests/agents-config.test.ts

@@ -14,6 +14,7 @@ import {
 	parseFrontmatter,
 	parseModelRef,
 	resolveAgentProfile,
+	withPinnedModelProfiles,
 } from "../lib/agents-config.ts";
 import { THINKING_LEVELS } from "../lib/model-routing-authority.ts";
 
@@ -193,6 +194,21 @@ test("parseAgentsConfig applies defaults, validates values, and silently ignores
 	assert.equal(parseAgentsConfig({ default_mode: "background" }, undefined).defaultMode, AGENT_MODE.BACKGROUND);
 });
 
+test("parseAgentsConfig resolves the tool-call stall ceiling above the idle silence budget", () => {
+	const defaults = parseAgentsConfig(undefined, undefined);
+	assert.equal(defaults.stallTimeoutMs, 4 * 60_000);
+	assert.equal(defaults.toolStallTimeoutMs, 30 * 60_000);
+	const explicit = parseAgentsConfig({ stall_timeout_ms: 12_000, tool_stall_timeout_ms: 20 * 60_000 }, undefined);
+	assert.equal(explicit.stallTimeoutMs, 12_000);
+	assert.equal(explicit.toolStallTimeoutMs, 20 * 60_000);
+	const projectWins = parseAgentsConfig({ tool_stall_timeout_ms: 20 * 60_000 }, { tool_stall_timeout_ms: 15 * 60_000 });
+	assert.equal(projectWins.toolStallTimeoutMs, 15 * 60_000);
+	for (const invalid of ["forever", 0, -1, 12.5, null]) {
+		assert.equal(parseAgentsConfig({ tool_stall_timeout_ms: invalid }, undefined).toolStallTimeoutMs, 30 * 60_000, `invalid tool_stall_timeout_ms ${String(invalid)} must fall back to the default`);
+	}
+	assert.equal(parseAgentsConfig({ stall_timeout_ms: 45 * 60_000, tool_stall_timeout_ms: 1_000 }, undefined).toolStallTimeoutMs, 45 * 60_000, "the tool ceiling must never fall below the idle budget");
+});
+
 test("resolveAgentProfile prefers the profile, then the definition, then the defaults", () => {
 	const config = parseAgentsConfig({ default_model: "openai-codex/gpt-6-astra", default_effort: "medium", model_profiles: { "gentle-ai-explore": { effort: "high" } } }, undefined);
 	const explore = parseAgentDefinition(EXPLORER, "/x/explore.md", "global");
@@ -203,3 +219,31 @@ test("resolveAgentProfile prefers the profile, then the definition, then the def
 	assert.deepEqual(resolveAgentProfile(bare, config), { model: { provider: "openai-codex", id: "gpt-6-astra" }, thinking: "medium", source: { model: "default", thinking: "default" } });
 	assert.deepEqual(resolveAgentProfile(bare, parseAgentsConfig(undefined, undefined)).source, { model: "unresolved", thinking: "unresolved" });
 });
+
+test("a pinned profile replaces subagent routing and leaves every other default alone", () => {
+	const global = parseAgentsConfig(
+		{
+			default_model: "openai-codex/gpt-6-astra",
+			default_effort: "medium",
+			default_mode: "background",
+			max_concurrency: 3,
+			model_profiles: { explore: { model: "openai-codex/gpt-5.6-terra", effort: "low" } },
+		},
+		{ model_profiles: { worker: { model: "anthropic/claude-sonnet-5" } } },
+	);
+	const pinned = withPinnedModelProfiles(global, { worker: { model: "openai/alpha", thinking: "minimal" } });
+	assert.deepEqual(pinned.modelProfiles, {
+		worker: { model: { provider: "openai", id: "alpha" }, thinking: "minimal" },
+	});
+	// Materialized global routing must not survive into a pinned repository: that
+	// leak is exactly the conflict a per-repository pin exists to remove.
+	assert.equal("explore" in pinned.modelProfiles, false);
+	// A pin redirects subagent routing only; the orchestrator routing and every
+	// operational default stay global.
+	assert.deepEqual({ ...pinned, modelProfiles: global.modelProfiles }, global);
+	// No pin, and no pin-shaped input, mean today's routing by identity.
+	assert.equal(withPinnedModelProfiles(global, undefined), global);
+	// A pinned profile that mentions no role still replaces the routing, so a
+	// repository can pin "everything inherits" without touching the global store.
+	assert.deepEqual(withPinnedModelProfiles(global, {}).modelProfiles, {});
+});

package/tests/agents-history.test.ts

@@ -1,10 +1,9 @@
 import assert from "node:assert/strict";
-import { spawnSync } from "node:child_process";
-import { mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test, { after } from "node:test";
-import { acquireTaskLock, historyDir, loadHistory, loadStoredTask, pruneHistory, saveTask } from "../lib/agents-history.ts";
+import { historyDir, loadHistory, loadStoredTask, pruneHistory, saveTask } from "../lib/agents-history.ts";
 import { applyTaskEvent, emptyThread, TASK_EVENT, TASK_STATUS, TaskStore, type TaskRecord } from "../lib/agents-protocol.ts";
 
 // Gentle Agents history: JSON per task, async, lazy, pruned by count.
@@ -13,13 +12,6 @@ const root = mkdtempSync(join(tmpdir(), "gentle-agents-history-"));
 after(() => rmSync(root, { recursive: true, force: true }));
 const dir = join(root, "tasks");
 
-function orphanLock(lockDir: string, id: string): void {
-	const moduleUrl = new URL("../lib/agents-history.ts", import.meta.url).href;
-	const source = `import { acquireTaskLock } from ${JSON.stringify(moduleUrl)}; const [dir, id] = process.argv.slice(-2); acquireTaskLock(dir, id);`;
-	const child = spawnSync(process.execPath, ["--experimental-strip-types", "--input-type=module", "-e", source, lockDir, id], { encoding: "utf8" });
-	assert.equal(child.status, 0, child.stderr || child.stdout);
-}
-
 function task(id: string, createdAt: number): TaskRecord {
 	return { id, agent: "explore", mode: "task", prompt: "p", label: "p", cwd: "/r", parentSessionId: "s", status: TASK_STATUS.COMPLETED, createdAt, startedAt: createdAt, endedAt: createdAt + 5, model: "m", thinking: undefined, sessionPath: null, error: null, result: "ok", lastStep: "done", lastActivityAt: createdAt, turns: 1, toolCalls: 0, tokens: 10, cost: 0.01 };
 }
@@ -41,20 +33,6 @@ test("saveTask writes a task with its thread and loadStoredTask reads it back",
 	assert.deepEqual(readdirSync(dir), ["a1.json"], "no temp file is left behind");
 });
 
-test("task reconciliation elections bypass dead candidates and fail closed for active or ambiguous candidates", () => {
-	const lockDir = join(root, "task-locks"), token = "11111111-1111-4111-8111-111111111111";
-	const held = acquireTaskLock(lockDir, "busy");
-	assert.match(held.path, /busy\.reconcile\.[0-9a-f-]+$/);
-	assert.throws(() => acquireTaskLock(lockDir, "busy"), /busy|active|ambiguous/i); held.release();
-	orphanLock(lockDir, "dead");
-	const deadName = readdirSync(lockDir).find(name => name.startsWith("dead.reconcile."))!;
-	const bypassed = acquireTaskLock(lockDir, "dead");
-	assert.notEqual(bypassed.path, join(lockDir, deadName)); assert.ok(!readdirSync(lockDir).includes(deadName)); bypassed.release();
-	const malformed = join(lockDir, `malformed.reconcile.${token}`); writeFileSync(malformed, "not-json");
-	assert.throws(() => acquireTaskLock(lockDir, "malformed"), /busy|active|ambiguous|malformed/i);
-	const foreign = join(lockDir, `foreign.reconcile.${token}`); writeFileSync(foreign, JSON.stringify({ schema: "gentle-pi.task-reconciliation-lock/v1", taskId: "foreign", token, pid: process.pid, host: "foreign-host" }));
-	assert.throws(() => acquireTaskLock(lockDir, "foreign"), /busy|active|ambiguous|foreign/i);
-});
 test("loadHistory skips broken files, sorts newest first, and pruneHistory keeps the newest N", async () => {
 	await saveTask(dir, task("b2", 3000), emptyThread());
 	await saveTask(dir, task("c3", 2000), emptyThread());
@@ -74,3 +52,13 @@ test("TaskStore.restore adds a stored task without clobbering a live one", () =>
 	assert.equal(store.restore({ ...task("r1", 1000), result: "other" }, emptyThread()), false);
 	assert.equal(store.get("r1")?.result, "ok");
 });
+
+test("retired remediation payloads remain readable and are never automatically pruned or replayed", async () => {
+	const legacyDir = join(root, "legacy-remediation");
+	const legacy = { ...task("legacy", 1), sddRemediation: { acquire: { requestId: "old" }, token: "historical", settlement: { state: "complete" } } };
+	await saveTask(legacyDir, legacy, emptyThread());
+	const before = readFileSync(join(legacyDir, "legacy.json"), "utf8");
+	assert.equal(await pruneHistory(legacyDir, 0), 0);
+	assert.deepEqual((await loadStoredTask(legacyDir, "legacy"))?.task, JSON.parse(before).task);
+	assert.equal(readFileSync(join(legacyDir, "legacy.json"), "utf8"), before);
+});