@selesai/code 0.12.0 → 0.13.1

package/dist/extensions/pi-subagents/test/unit/worktree-cleanup-plan.test.ts

@@ -0,0 +1,349 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import {
+	__testables,
+	buildWorktreeCleanupPlan,
+	createWorktreeCleanupPlan,
+	formatWorktreeCleanupPlan,
+	type BuildWorktreeCleanupPlanInput,
+	type WorktreeCleanupPlan,
+} from "../../src/runs/shared/worktree-cleanup-plan.ts";
+import { DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS } from "../../src/runs/background/active-run-index.ts";
+import { createWorktrees, type WorktreeSetup } from "../../src/runs/shared/worktree.ts";
+
+function git(cwd: string, args: string[]): string {
+	return execFileSync("git", ["-C", cwd, ...args], { encoding: "utf-8" }).trim();
+}
+
+function createRepo(prefix: string): string {
+	const repo = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+	git(repo, ["init"]);
+	git(repo, ["config", "user.email", "cleanup-tests@example.com"]);
+	git(repo, ["config", "user.name", "Cleanup Tests"]);
+	fs.writeFileSync(path.join(repo, "tracked.txt"), "initial\n", "utf-8");
+	git(repo, ["add", "tracked.txt"]);
+	git(repo, ["commit", "-m", "initial"]);
+	return repo;
+}
+
+function removeGeneratedWorktrees(repo: string, setup: WorktreeSetup | undefined): void {
+	for (const worktree of setup?.worktrees ?? []) {
+		try { execFileSync("git", ["-C", repo, "worktree", "remove", "--force", worktree.path], { stdio: "ignore" }); } catch {}
+		try { execFileSync("git", ["-C", repo, "branch", "-D", worktree.branch], { stdio: "ignore" }); } catch {}
+	}
+	try { execFileSync("git", ["-C", repo, "worktree", "prune"], { stdio: "ignore" }); } catch {}
+}
+
+function writeManifest(input: {
+	repo: string;
+	manifestPath: string;
+	setup: WorktreeSetup;
+	runId?: string;
+	source?: "foreground" | "async";
+	childStatus?: string;
+	baseCommit?: string;
+	preserved?: boolean;
+	outputPath?: string;
+	patch?: { path: string; changed: boolean; error?: string };
+}): void {
+	const worktree = input.setup.worktrees[0]!;
+	const baseCommit = input.baseCommit ?? git(input.repo, ["rev-parse", "HEAD"]);
+	const patch = input.patch ?? {
+		path: path.join(path.dirname(input.manifestPath), "worktree.patch"),
+		changed: false,
+	};
+	fs.mkdirSync(path.dirname(input.manifestPath), { recursive: true });
+	fs.writeFileSync(input.manifestPath, JSON.stringify({
+		version: 1,
+		runId: input.runId ?? "cleanup-run",
+		mode: "parallel",
+		source: input.source ?? "foreground",
+		cwd: input.repo,
+		createdAt: 1,
+		updatedAt: 1,
+		groups: [{
+			stepIndex: 0,
+			baseCommit,
+			repoRoot: input.repo,
+			children: [{
+				index: 0,
+				taskIndex: worktree.index,
+				agent: "worker",
+				status: input.childStatus ?? "completed",
+				summary: "done",
+				...(input.outputPath ? { outputPath: input.outputPath } : {}),
+				patch: {
+					path: patch.path,
+					branch: worktree.branch,
+					changed: patch.changed,
+					diffStat: "",
+					filesChanged: patch.changed ? 1 : 0,
+					insertions: patch.changed ? 1 : 0,
+					deletions: 0,
+					...(patch.error ? { error: patch.error } : {}),
+				},
+			}],
+			cleanup: {
+				state: "partial",
+				pruned: false,
+				tasks: [{
+					index: worktree.index,
+					path: worktree.path,
+					branch: worktree.branch,
+					worktreeRemoved: false,
+					branchRemoved: false,
+					preserved: input.preserved ?? true,
+				}],
+			},
+		}],
+	}, null, 2), "utf-8");
+	if (patch.changed) fs.writeFileSync(patch.path, "captured patch\n", "utf-8");
+}
+
+function entriesByPath(plan: WorktreeCleanupPlan): Map<string, WorktreeCleanupPlan["entries"][number]> {
+	return new Map(plan.entries.map((entry) => [entry.path, entry]));
+}
+
+function buildPlan(input: BuildWorktreeCleanupPlanInput): WorktreeCleanupPlan {
+	return buildWorktreeCleanupPlan({ ...input, foregroundRunOwnership: input.foregroundRunOwnership ?? (() => "terminal") });
+}
+
+describe("worktree cleanup plan", () => {
+	it("prefers native realpath for Windows alias normalization and falls back when unavailable", () => {
+		let fallbackCalls = 0;
+		const nativePath = "C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cleanup";
+		assert.equal(
+			__testables.realpathExisting(
+				"C:\\Users\\RUNNER~1\\AppData\\Local\\Temp\\cleanup",
+				() => nativePath,
+				() => { fallbackCalls++; return "fallback"; },
+			),
+			nativePath,
+		);
+		assert.equal(fallbackCalls, 0);
+		assert.equal(
+			__testables.realpathExisting(
+				"C:\\Users\\RUNNER~1\\AppData\\Local\\Temp\\cleanup",
+				() => { throw new Error("native realpath unavailable"); },
+				() => { fallbackCalls++; return "fallback"; },
+			),
+			"fallback",
+		);
+		assert.equal(fallbackCalls, 1);
+	});
+
+	it("builds and persists a deterministic metadata-backed plan without removing worktrees", () => {
+		const repo = createRepo("pi-cleanup-plan-safe-");
+		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = createWorktrees(repo, "safe", 1, { baseDir });
+			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
+			writeManifest({ repo, manifestPath, setup });
+			fs.mkdirSync(path.join(baseDir, "unrelated-directory"));
+
+			const first = buildPlan({ repo, worktreeBaseDir: baseDir, now: 10_000, planId: "fixed-plan" });
+			const second = buildPlan({ repo, worktreeBaseDir: baseDir, now: 10_000, planId: "another-plan" });
+			assert.deepEqual(first.entries, second.entries);
+			assert.equal(first.contentHash, second.contentHash);
+			assert.equal(first.entries.length, 1);
+			assert.equal(first.entries[0]?.decision, "remove");
+			assert.equal(first.entries[0]?.state, "safe");
+			assert.equal(first.entries[0]?.willDeleteBranch, true);
+			assert.match(first.entries[0]?.preconditions.statusDigest ?? "", /^[0-9a-f]{64}$/);
+			assert.equal(first.entries.some((entry) => entry.path.includes("unrelated-directory")), false);
+
+			const created = createWorktreeCleanupPlan({ repo, worktreeBaseDir: baseDir, now: 10_000, planId: "fixed-plan", foregroundRunOwnership: () => "terminal" });
+			assert.equal(created.plan.planId, "fixed-plan");
+			assert.ok(fs.existsSync(created.planPath));
+			assert.match(formatWorktreeCleanupPlan(created), /Will remove[\s\S]*Will delete local branches[\s\S]*Plan-only mode: no worktrees or branches were removed/);
+			assert.ok(fs.existsSync(setup.worktrees[0]!.path));
+			assert.notEqual(git(repo, ["branch", "--list", setup.worktrees[0]!.branch]), "");
+
+			for (const childStatus of ["complete", "rejected"] as const) {
+				writeManifest({ repo, manifestPath, setup, childStatus });
+				const compatibilityPlan = buildPlan({ repo, worktreeBaseDir: baseDir, now: 10_000, planId: `${childStatus}-plan` });
+				assert.equal(compatibilityPlan.entries[0]?.decision, "remove");
+				assert.equal(compatibilityPlan.entries[0]?.state, "safe");
+			}
+
+			writeManifest({ repo, manifestPath, setup, childStatus: "detached" });
+			const detachedPlan = buildPlan({ repo, worktreeBaseDir: baseDir, now: 10_000, planId: "detached-plan" });
+			assert.equal(detachedPlan.entries[0]?.decision, "keep");
+			assert.equal(detachedPlan.entries[0]?.state, "active");
+		} finally {
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(baseDir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps dirty and unowned worktrees out of the removable set", () => {
+		const repo = createRepo("pi-cleanup-plan-unknown-");
+		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = createWorktrees(repo, "unknown", 2, { baseDir });
+			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
+			writeManifest({ repo, manifestPath, setup });
+			fs.writeFileSync(path.join(setup.worktrees[0]!.path, "tracked.txt"), "dirty\n", "utf-8");
+
+			const plan = buildPlan({ repo, worktreeBaseDir: baseDir, now: 20_000, planId: "unknown-plan" });
+			const entries = entriesByPath(plan);
+			const dirty = entries.get(__testables.realpathExisting(setup.worktrees[0]!.path));
+			const unowned = entries.get(__testables.realpathExisting(setup.worktrees[1]!.path));
+			assert.equal(dirty?.decision, "keep");
+			assert.equal(dirty?.state, "dirty");
+			assert.match(dirty?.reasons.join(" ") ?? "", /uncommitted|untracked/i);
+			assert.equal(unowned?.decision, "unknown");
+			assert.equal(unowned?.state, "unknown");
+			assert.match(unowned?.reasons.join(" ") ?? "", /no matching extension-owned/i);
+			assert.ok(fs.existsSync(setup.worktrees[0]!.path));
+			assert.ok(fs.existsSync(setup.worktrees[1]!.path));
+		} finally {
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(baseDir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps active async ownership and reports missing Git worktrees as stale", () => {
+		const repo = createRepo("pi-cleanup-plan-active-");
+		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = createWorktrees(repo, "active", 1, { baseDir });
+			const asyncDir = path.join(repo, ".pi-subagents", "async", "active-run");
+			const manifestPath = path.join(asyncDir, "handoff.json");
+			writeManifest({ repo, manifestPath, setup, runId: "active-run", source: "async" });
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ runId: "active-run", state: "running" }), "utf-8");
+			fs.mkdirSync(path.join(path.dirname(asyncDir), ".active-runs"), { recursive: true });
+			fs.writeFileSync(path.join(path.dirname(asyncDir), ".active-runs", path.basename(asyncDir)), "", "utf-8");
+			const activePlan = buildPlan({ repo, handoffPath: manifestPath, worktreeBaseDir: baseDir, now: 30_000, planId: "active-plan" });
+			assert.equal(activePlan.entries[0]?.state, "active");
+			assert.equal(activePlan.entries[0]?.decision, "keep");
+
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ runId: "active-run", state: "complete" }), "utf-8");
+			fs.rmSync(setup.worktrees[0]!.path, { recursive: true, force: true });
+			const stalePlan = buildPlan({ repo, handoffPath: manifestPath, worktreeBaseDir: baseDir, now: 30_000, planId: "stale-plan" });
+			assert.equal(stalePlan.entries[0]?.state, "stale");
+			assert.equal(stalePlan.entries[0]?.decision, "unknown");
+			assert.match(stalePlan.entries[0]?.reasons.join(" ") ?? "", /not present in Git worktree state|missing from disk/i);
+		} finally {
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(baseDir, { recursive: true, force: true });
+		}
+	});
+
+	it("requires foreground ownership proof instead of inferring activity from the artifacts directory", () => {
+		const repo = createRepo("pi-cleanup-plan-foreground-");
+		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = createWorktrees(repo, "foreground", 1, { baseDir });
+			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
+			writeManifest({ repo, manifestPath, setup, runId: "foreground-run", source: "foreground" });
+			const noProof = buildWorktreeCleanupPlan({ repo, handoffPath: manifestPath, worktreeBaseDir: baseDir, now: 35_000, planId: "foreground-no-proof" });
+			assert.equal(noProof.entries[0]?.state, "unknown");
+			assert.equal(noProof.entries[0]?.decision, "unknown");
+			assert.match(noProof.entries[0]?.reasons.join(" ") ?? "", /foreground owning-run state is not provably terminal/i);
+
+			const active = buildPlan({ repo, handoffPath: manifestPath, worktreeBaseDir: baseDir, now: 35_000, planId: "foreground-active", foregroundRunOwnership: () => "active" });
+			assert.equal(active.entries[0]?.state, "active");
+			assert.equal(active.entries[0]?.decision, "keep");
+		} finally {
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(baseDir, { recursive: true, force: true });
+		}
+	});
+
+	it("requires a recorded patch or local target ancestry for committed divergence", () => {
+		const repo = createRepo("pi-cleanup-plan-divergence-");
+		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = createWorktrees(repo, "divergence", 1, { baseDir });
+			const manifestPath = path.join(repo, ".pi-subagents", "artifacts", "handoff.json");
+			writeManifest({ repo, manifestPath, setup });
+			const worktree = setup.worktrees[0]!;
+			fs.writeFileSync(path.join(worktree.path, "unmerged.txt"), "unmerged\n", "utf-8");
+			git(worktree.path, ["add", "unmerged.txt"]);
+			git(worktree.path, ["commit", "-m", "unmerged"]);
+
+			const unmerged = buildPlan({ repo, worktreeBaseDir: baseDir, now: 40_000, planId: "unmerged-plan" });
+			assert.equal(unmerged.entries[0]?.decision, "keep");
+			assert.equal(unmerged.entries[0]?.state, "ineligible");
+			assert.match(unmerged.entries[0]?.reasons.join(" ") ?? "", /neither preserved.*nor merged/i);
+
+			const patchPath = path.join(repo, ".pi-subagents", "artifacts", "divergence.patch");
+			writeManifest({ repo, manifestPath, setup, patch: { path: patchPath, changed: true } });
+			const captured = buildPlan({ repo, worktreeBaseDir: baseDir, now: 40_000, planId: "captured-plan" });
+			assert.equal(captured.entries[0]?.decision, "remove");
+			assert.equal(captured.entries[0]?.state, "safe");
+			assert.equal(captured.entries[0]?.willDeleteBranch, false);
+		} finally {
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(baseDir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps stale markers, pending captures, and inconsistent cleanup metadata non-removable", () => {
+		const repo = createRepo("pi-cleanup-plan-stale-");
+		const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-cleanup-plan-base-"));
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = createWorktrees(repo, "stale", 1, { baseDir });
+			const asyncDir = path.join(repo, ".pi-subagents", "async", "stale-run");
+			const manifestPath = path.join(asyncDir, "handoff.json");
+			writeManifest({ repo, manifestPath, setup, runId: "stale-run", source: "async" });
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ runId: "stale-run", state: "complete" }), "utf-8");
+			const markerPath = path.join(path.dirname(asyncDir), ".active-runs", path.basename(asyncDir));
+			fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+			fs.writeFileSync(markerPath, "", "utf-8");
+			fs.utimesSync(markerPath, new Date(0), new Date(0));
+			const stale = buildPlan({ repo, handoffPath: manifestPath, worktreeBaseDir: baseDir, now: DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS + 1, planId: "stale-marker-plan" });
+			assert.equal(stale.entries[0]?.state, "stale");
+			assert.equal(stale.entries[0]?.decision, "unknown");
+
+			fs.rmSync(markerPath, { force: true });
+			writeManifest({ repo, manifestPath, setup, source: "foreground" });
+			fs.rmSync(path.join(asyncDir, "status.json"), { force: true });
+			const pending = JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as { groups: Array<{ children: Array<{ taskIndex: number }>; cleanup: { state: string; tasks: Array<{ reason?: string }> } }> };
+			pending.groups[0]!.cleanup.tasks[0]!.reason = "cleanup pending durable handoff capture";
+			fs.writeFileSync(manifestPath, JSON.stringify(pending), "utf-8");
+			const pendingPlan = buildPlan({ repo, handoffPath: manifestPath, worktreeBaseDir: baseDir, now: 50_000, planId: "pending-capture-plan" });
+			assert.equal(pendingPlan.entries[0]?.state, "ineligible");
+			assert.equal(pendingPlan.entries[0]?.decision, "keep");
+
+			pending.groups[0]!.cleanup.tasks[0]!.reason = undefined;
+			pending.groups[0]!.cleanup.state = "complete";
+			fs.writeFileSync(manifestPath, JSON.stringify(pending), "utf-8");
+			const inconsistent = buildPlan({ repo, handoffPath: manifestPath, worktreeBaseDir: baseDir, now: 50_000, planId: "inconsistent-cleanup-plan" });
+			assert.equal(inconsistent.entries[0]?.state, "unknown");
+			assert.equal(inconsistent.entries[0]?.decision, "unknown");
+
+			pending.groups[0]!.cleanup.state = "partial";
+			pending.groups[0]!.children.push({ taskIndex: pending.groups[0]!.children[0]!.taskIndex });
+			fs.writeFileSync(manifestPath, JSON.stringify(pending), "utf-8");
+			const duplicateChild = buildPlan({ repo, handoffPath: manifestPath, worktreeBaseDir: baseDir, now: 50_000, planId: "duplicate-child-plan" });
+			assert.equal(duplicateChild.entries[0]?.state, "unknown");
+			assert.match(duplicateChild.entries[0]?.reasons.join(" ") ?? "", /no matching extension-owned/i);
+
+			writeManifest({ repo, manifestPath, setup, source: "foreground", outputPath: path.join(repo, "missing-output.json") });
+			const missingReport = buildPlan({ repo, handoffPath: manifestPath, worktreeBaseDir: baseDir, now: 50_000, planId: "missing-report-plan" });
+			assert.equal(missingReport.entries[0]?.state, "unknown");
+			assert.match(missingReport.entries[0]?.reasons.join(" ") ?? "", /durable handoff path is missing/i);
+		} finally {
+			removeGeneratedWorktrees(repo, setup);
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(baseDir, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/worktree.test.ts

@@ -74,6 +74,27 @@ describe("worktree", () => {
 		}
 	});
 
+	it("invokes beforeCreate with deterministic ownership metadata before creating worktrees", () => {
+		const repoDir = createRepo("pi-worktree-before-create-");
+		let setup: WorktreeSetup | undefined;
+		let planned: WorktreeSetup | undefined;
+		try {
+			setup = createWorktrees(repoDir, "before-create", 1, {
+				beforeCreate: (candidate) => {
+					planned = candidate;
+					assert.equal(fs.existsSync(candidate.worktrees[0]!.path), false);
+					assert.equal(candidate.worktrees[0]!.branch, "pi-parallel-before-create-0");
+				},
+			});
+			assert.equal(planned?.baseCommit, setup.baseCommit);
+			assert.equal(planned?.worktrees[0]?.path, setup.worktrees[0]?.path);
+			assert.equal(fs.existsSync(setup.worktrees[0]!.path), true);
+		} finally {
+			if (setup) cleanupWorktrees(setup);
+			cleanupRepo(repoDir);
+		}
+	});
+
 	it("createWorktrees maps subdirectory cwd to each agentCwd", () => {
 		const repoDir = createRepo("pi-worktree-subdir-");
 		const nestedDir = path.join(repoDir, "packages", "app");

package/dist/extensions/pi-subagents/test/unit/writer-budget-guidance.test.ts

@@ -6,13 +6,13 @@ import { describe, it } from "node:test";
 const readProjectFile = (file: string): string => readFileSync(join(process.cwd(), file), "utf-8");
 
 describe("writer budget guidance", () => {
-	it("keeps hard turn and tool caps off mutation-capable workers", () => {
+	it("keeps hard tool and usage caps off mutation-capable workers", () => {
 		const toolReference = readProjectFile("docs/tool-reference.md");
 		const skill = readProjectFile("skills/pi-subagents/SKILL.md");
 		const reviewLoop = readProjectFile("prompts/review-loop.md");
 
 		for (const text of [toolReference, skill, reviewLoop]) {
-			assert.match(text, /As a conservative orchestration policy, do not (?:pass|set) `turnBudget`(?:, a hard `toolBudget`, or a tight `usageBudget`| or a hard `toolBudget`)/);
+			assert.match(text, /As a conservative orchestration policy, do not (?:pass|set) a hard `toolBudget`/);
 			assert.match(text, /default tool budget blocks read\/search tools rather than mutation tools/i);
 			assert.match(text, /checkpoint after the current tool returns/);
 			assert.match(text, /changed files/);
@@ -22,9 +22,4 @@ describe("writer budget guidance", () => {
 		assert.match(toolReference, /elapsed timeout is not a mutation-safe boundary/i);
 	});
 
-	it("documents deferred hard-limit termination at tool-using boundaries", () => {
-		const toolReference = readProjectFile("docs/tool-reference.md");
-		assert.match(toolReference, /termination occurs at the next assistant boundary/);
-		assert.match(toolReference, /`termination-deferred`/);
-	});
 });

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/effect/index.ts

@@ -0,0 +1,13 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+import { noServiceConstructorImportsRule } from "./rules/no-service-constructor-imports.ts";
+
+/** Opt-in Oxlint rules for Effect service and Layer architecture. */
+const antiSlopEffectPlugin = eslintCompatPlugin({
+	meta: { name: "anti-slop-effect" },
+	rules: {
+		"no-service-constructor-imports": noServiceConstructorImportsRule,
+	},
+});
+
+export default antiSlopEffectPlugin;

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/effect/rules/no-service-constructor-imports.ts

@@ -0,0 +1,52 @@
+import { defineRule } from "@oxlint/plugins";
+
+import type { ESTree } from "@oxlint/plugins";
+
+const SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
+const TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
+
+function isProjectLocalImport(source: string): boolean {
+	return source.startsWith("./") || source.startsWith("../");
+}
+
+function getImportedName(specifier: ESTree.ImportSpecifier): string {
+	if (specifier.imported.type === "Identifier") return specifier.imported.name;
+	return specifier.imported.value;
+}
+
+/** Keep dependency-bearing Effect service constructors local to their owning capability modules. */
+export const noServiceConstructorImportsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Disallow project-local make<CapabilityName> imports outside test and spec files.",
+		},
+		messages: {
+			serviceConstructorImport:
+				'Do not import Effect service constructor "{{name}}" into runtime code. Import the owning Layer, yield the contextual service, and allow its requirements to propagate to the composition root.',
+		},
+	},
+	create(context) {
+		const isTestFile = TEST_FILE.test(context.filename.replaceAll("\\", "/"));
+
+		return {
+			ImportDeclaration(node) {
+				if (isTestFile || !isProjectLocalImport(node.source.value)) return;
+
+				for (const specifier of node.specifiers) {
+					if (specifier.type !== "ImportSpecifier") continue;
+
+					const importedName = getImportedName(specifier);
+					if (!SERVICE_CONSTRUCTOR_NAME.test(importedName)) continue;
+
+					context.report({
+						node: specifier,
+						messageId: "serviceConstructorImport",
+						data: { name: importedName },
+					});
+				}
+			},
+		};
+	},
+});

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/index.ts

@@ -0,0 +1,41 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+import { noChainedTypeAssertionsRule } from "./rules/no-chained-type-assertions.ts";
+import { noConditionalEmptyObjectSpreadRule } from "./rules/no-conditional-empty-object-spread.ts";
+import { noKnownValueWideningRule } from "./rules/no-known-value-widening.ts";
+import { noModuleMockingRule } from "./rules/no-module-mocking.ts";
+import { noObjectParametersRule } from "./rules/no-object-parameters.ts";
+import { noReflectApplyRule } from "./rules/no-reflect-apply.ts";
+import { noReflectGetRule } from "./rules/no-reflect-get.ts";
+import { noRuntimeTypeofRule } from "./rules/no-runtime-typeof.ts";
+import { noForbiddenTermInSymbolNamesRule } from "./rules/no-shape-in-symbol-names.ts";
+import { noUnknownParametersRule } from "./rules/no-unknown-parameters.ts";
+import { noUnknownReturnsRule } from "./rules/no-unknown-returns.ts";
+import { noUnknownTypeAliasesRule } from "./rules/no-unknown-type-aliases.ts";
+import { noUnsafeDictionaryTypeRule } from "./rules/no-unsafe-dictionary-type.ts";
+import { noWidenThenAssertRule } from "./rules/no-widen-then-assert.ts";
+import { requireSafetyCommentForTypeAssertionRule } from "./rules/require-safety-comment-for-type-assertion.ts";
+
+/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
+const antiSlopPlugin = eslintCompatPlugin({
+	meta: { name: "anti-slop" },
+	rules: {
+		"no-chained-type-assertions": noChainedTypeAssertionsRule,
+		"no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
+		"no-known-value-widening": noKnownValueWideningRule,
+		"no-module-mocking": noModuleMockingRule,
+		"no-object-parameters": noObjectParametersRule,
+		"no-reflect-apply": noReflectApplyRule,
+		"no-reflect-get": noReflectGetRule,
+		"no-runtime-typeof": noRuntimeTypeofRule,
+		"no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+		"no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
+		"no-unknown-parameters": noUnknownParametersRule,
+		"no-unknown-returns": noUnknownReturnsRule,
+		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
+		"no-widen-then-assert": noWidenThenAssertRule,
+		"require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
+	},
+});
+
+export default antiSlopPlugin;

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/rules/no-chained-type-assertions.ts

@@ -0,0 +1,77 @@
+import { defineRule } from "@oxlint/plugins";
+import type { ESTree } from "@oxlint/plugins";
+
+type TypeAssertionExpression = ESTree.TSAsExpression | ESTree.TSTypeAssertion;
+
+function isTypeAssertionExpression(node: ESTree.Node): node is TypeAssertionExpression {
+  return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
+}
+
+function unwrapParenthesizedExpression(expression: ESTree.Expression): ESTree.Expression {
+  let current = expression;
+  while (current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+
+function isConstAssertion(node: TypeAssertionExpression): boolean {
+  const { typeAnnotation } = node;
+  return (
+    typeAnnotation.type === "TSTypeReference" &&
+    typeAnnotation.typeName.type === "Identifier" &&
+    typeAnnotation.typeName.name === "const"
+  );
+}
+
+function isOutermostAssertionInChain(node: TypeAssertionExpression): boolean {
+  let current: ESTree.Expression = node;
+  let parent = node.parent;
+
+  while (parent.type === "ParenthesizedExpression" && parent.expression === current) {
+    current = parent;
+    parent = parent.parent;
+  }
+
+  return !isTypeAssertionExpression(parent) || parent.expression !== current;
+}
+
+function isForbiddenAssertionChain(node: TypeAssertionExpression): boolean {
+  let assertionCount = 0;
+  let hasNonConstAssertion = false;
+  let current: ESTree.Expression = node;
+
+  while (isTypeAssertionExpression(current)) {
+    assertionCount += 1;
+    hasNonConstAssertion ||= !isConstAssertion(current);
+    current = unwrapParenthesizedExpression(current.expression);
+  }
+
+  return assertionCount > 1 && hasNonConstAssertion;
+}
+
+/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
+export const noChainedTypeAssertionsRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow chained TypeScript as and angle-bracket assertions, including parenthesized chains.",
+    },
+    messages: {
+      chained:
+        "This assertion chain discards type evidence. Keep the original precise type, or parse untrusted input at its boundary before narrowing it.",
+    },
+  },
+  createOnce(context) {
+    const checkTypeAssertion = (node: TypeAssertionExpression) => {
+      if (!isOutermostAssertionInChain(node) || !isForbiddenAssertionChain(node)) return;
+      context.report({ node, messageId: "chained" });
+    };
+
+    return {
+      TSAsExpression: checkTypeAssertion,
+      TSTypeAssertion: checkTypeAssertion,
+    };
+  },
+});

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/rules/no-conditional-empty-object-spread.ts

@@ -0,0 +1,49 @@
+import { defineRule } from "@oxlint/plugins";
+import type { ESTree } from "@oxlint/plugins";
+
+function unwrapParentheses(node: ESTree.Expression): ESTree.Expression {
+  let current = node;
+  while (current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+
+function isEmptyObjectExpression(node: ESTree.Expression): boolean {
+  return node.type === "ObjectExpression" && node.properties.length === 0;
+}
+
+function isConditionalEmptyObjectSpread(node: ESTree.Expression): boolean {
+  const conditional = unwrapParentheses(node);
+  return (
+    conditional.type === "ConditionalExpression" &&
+    (isEmptyObjectExpression(conditional.consequent) ||
+      isEmptyObjectExpression(conditional.alternate))
+  );
+}
+
+/** Ban conditional empty-object spreads without changing their omission semantics. */
+export const noConditionalEmptyObjectSpreadRule = defineRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Disallow object spreads that conditionally spread an empty object to omit fields.",
+    },
+    messages: {
+      avoid:
+        "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present.",
+    },
+  },
+  createOnce(context) {
+    return {
+      SpreadElement(node) {
+        if (node.parent.type !== "ObjectExpression") return;
+
+        if (isConditionalEmptyObjectSpread(node.argument)) {
+          context.report({ node, messageId: "avoid" });
+        }
+      },
+    };
+  },
+});