Group the sources into aliased modules and lint with the published plugins (#23)

Groups the flat `src/` into cohesive modules and turns on the published lint plugins. No behavior change.

## Module layout

Each module is a direct `src/` subfolder with an `index.ts` barrel and a `#` alias in `package.json` `imports` (layer order, top first):

| Alias | Files |
| --- | --- |
| `#prepare` | `index.ts` (the prepare phase entry point) |
| `#run` | `index.ts` (the run phase entry point) |
| `#post` | `index.ts` (the post phase entry point), `post.ts`, `post.test.ts` |
| `#agents` | `auth.ts`, `opencode.ts` (Codex / Claude Code sign-in, OpenCode args and output) |
| `#processes` | `child.ts`, `isolation.ts` |
| `#runtime` | `runtime.ts`, `credentials.ts` |
| `#profiles` | `profiles.ts` |
| `#common` | `errors.ts`, `json.ts` |
| `#testing` | `index.ts` (unchanged) |

Every top-level entry of `src/` is an aliased module folder. Tests stay next to their code as `*.test.ts`. Each phase's `index.ts` is its entry point, and `action.yml` now runs `node src/<phase>/index.ts`. The post phase's logic moved to `src/post/post.ts` so its test can import it; `index.ts` keeps the env reading and the `import.meta.main` call. `run`'s prompt URL is now `../../prompt.md`. `scripts/protect-source.sh` now copies `src/` recursively (it used to copy `src/*.ts` only), and the workflow test checks that module files get staged too.

## Lint plugins

- New devDependencies: `eslint-plugin-explicit-types@^0.6.1` and `eslint-plugin-import-structure@^0.10.2`, both in `jsPlugins`. The lockfile comes from a real `npm install`.
- Enabled configs: `importStructure.configs.modules`, `explicitTypes.configs.concrete`, `explicitTypes.configs.absence`.
- **explicit-types `naming` is off** (the other app repos turn it on). Its `upper-snake-string-unions` and `no-upper-snake-object-keys` rules fire on wire tokens this repo doesn't choose: profile types `"claude" | "codex" | "opencode"` from `profiles.json`, failure reasons posted to Gitea, Gitea's `"new" | "old"` side, and environment variable names such as `PATH`. Satisfying them would change behavior or need opt-outs. This is logged as an open question for the user.

Lint fixes, all type-level:
- `Pick<BotProfile, "type" | "model">` became a named `ProfileIdentity` interface that `BotProfile`, `ProfileFailure`, and `RuntimeProfile` extend. `RuntimeOutcome` is now `RuntimeSuccess | RuntimeFailure`.
- Inline object types became named interfaces.
- `Record<string, string>` env maps became `NodeJS.ProcessEnv`. `JsonObject` and the verdict table became `NodeJS.Dict<…>`.
- `T | undefined` locals and returns became `T | null` with matching checks. `typeof fetch` became a `Fetcher` type.
- Claude's result fields are held in camelCase (`isError`, `apiErrorStatus`) after parsing, because `id-match` rejects snake_case interface members.
- Duplicate import sources are merged (`import-structure/no-duplicate-import-source`).

## Verification

- `vp check`: clean.
- `vp test`: 61 passed and 5 skipped as a normal user. All 66 passed as root in `node:24-bookworm`.
- Each phase (`node src/<phase>/index.ts`) run from a `protect-source.sh` copy loads its full alias graph under Node.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Reviewed-on: #23
Reviewed-by: bot <noreply@capsulizers.com>
Co-authored-by: Danny Kim <temeddix@gmail.com>
Co-committed-by: Danny Kim <temeddix@gmail.com>

src/processes/isolation.test.ts

@@ -0,0 +1,112 @@
+import { spawnSync, type SpawnSyncReturns } from "node:child_process";
+import { chmod, chown, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import process from "node:process";
+import { expect, test } from "vite-plus/test";
+
+import { isNotFound } from "#common";
+import type { RuntimeProfile } from "#runtime";
+import { currentUid, IS_ROOT, IS_WINDOWS, makeTempDir } from "#testing";
+
+import { isRunnableProfileProcess, killProfileProcesses, readProfileFile } from "./isolation.ts";
+
+const profile = (uid: number, home: string): RuntimeProfile => ({
+  index: uid - 20_000,
+  type: "claude",
+  model: "test",
+  uid,
+  gid: uid,
+  home,
+  tokenFile: null,
+});
+
+// Runs a command as the profile's user from the root directory. Without `env`
+// it inherits this process's environment.
+function runAs(
+  selected: RuntimeProfile,
+  command: string,
+  args: string[],
+  env?: NodeJS.ProcessEnv,
+): SpawnSyncReturns<string> {
+  return spawnSync(command, args, {
+    cwd: "/",
+    uid: selected.uid,
+    gid: selected.gid,
+    encoding: "utf8",
+    ...(env !== undefined && { env }),
+  });
+}
+
+test("zombie process entries are already quiescent", () => {
+  const status = "State:\tZ (zombie)\nUid:\t20010\t20010\t20010\t20010\n";
+  expect(isRunnableProfileProcess(status, 20_010)).toBe(false);
+});
+
+test.skipIf(IS_WINDOWS)("refuses to read a profile result symlink as root", async () => {
+  const root = await makeTempDir();
+  try {
+    const secret = `${root}/reviewer-token`;
+    const result = `${root}/result.md`;
+    await writeFile(secret, "reviewer-secret", { mode: 0o600 });
+    await symlink(secret, result);
+
+    await expect(() => readProfileFile(profile(currentUid(), root), result)).rejects.toThrow(
+      "regular private file",
+    );
+  } finally {
+    await rm(root, { recursive: true });
+  }
+});
+
+test.skipIf(!IS_ROOT)("a profile process can read only its own private files", async () => {
+  const root = await makeTempDir();
+  await chmod(root, 0o711);
+  try {
+    const homeA = `${root}/a`;
+    const homeB = `${root}/b`;
+    await mkdir(homeA, { mode: 0o700 });
+    await mkdir(homeB, { mode: 0o700 });
+    await chown(homeA, 20_000, 20_000);
+    await chown(homeB, 20_001, 20_001);
+    await writeFile(`${homeA}/token`, "own", { mode: 0o600 });
+    await chown(`${homeA}/token`, 20_000, 20_000);
+    await writeFile(`${homeB}/token`, "sibling", { mode: 0o600 });
+    await chown(`${homeB}/token`, 20_001, 20_001);
+    await writeFile(`${root}/reviewer`, "root", { mode: 0o600 });
+
+    const selected = profile(20_000, homeA);
+    const own = runAs(selected, "/bin/cat", [`${homeA}/token`]);
+    const sibling = runAs(selected, "/bin/cat", [`${homeB}/token`]);
+    const reviewer = runAs(selected, "/bin/cat", [`${root}/reviewer`]);
+
+    expect(own.stdout).toBe("own");
+    expect(own.status).toBe(0);
+    expect(sibling.status).not.toBe(0);
+    expect(reviewer.status).not.toBe(0);
+  } finally {
+    await rm(root, { recursive: true });
+  }
+});
+
+test.skipIf(!IS_ROOT)("cleanup leaves no runnable daemonized process", async () => {
+  const selected = profile(20_010, "/tmp");
+  const launched = runAs(selected, "/bin/sh", ["-c", "sleep 60 >/dev/null 2>&1 & echo $!"]);
+  const pid = Number(launched.stdout.trim());
+  expect(Number.isInteger(pid)).toBe(true);
+
+  await killProfileProcesses(selected.uid);
+
+  const status = await readFile(`/proc/${pid}/status`, "utf8").catch((error: unknown) => {
+    if (isNotFound(error)) return null;
+    throw error;
+  });
+  expect(status === null || !isRunnableProfileProcess(status, selected.uid)).toBe(true);
+});
+
+test.skipIf(!IS_ROOT)("the agent process cannot read its coordinator environment", () => {
+  const selected = profile(20_020, "/tmp");
+  const result = runAs(selected, "/usr/bin/cat", [`/proc/${process.pid}/environ`], {
+    PARENT_SECRET: "must-not-cross-boundary",
+  });
+
+  expect(result.status).not.toBe(0);
+});