pstack-claude-mirror 0.9.133-mirror.1 → 0.9.134

package/plugins/pstack/skills/poteto-mode/references/copilot-tools.md

@@ -27,6 +27,7 @@ pstack skills are written in Claude Code tool language (the `Skill` tool, the `A
 poteto-mode's Subagents section sets Claude-specific defaults (`subagent_type: "pstack:poteto-agent"`, `run_in_background: true`). On GitHub Copilot:
 
 - The plugin's agents load as `task` agent types under their namespaced names, `pstack:poteto-agent`, `pstack:comment-sicko`, `pstack:thermo-nuclear-review-subagent`, and `pstack:thermo-nuclear-code-quality-review-subagent`. Pass the skill's `subagent_type` as `agent_type` unchanged.
+- The VS Code agents window rejects those agent types as unknown. There, dispatch `agent_type: "general-purpose"` and tell it in the prompt to read its instructions in full first: the `poteto-mode` skill for `pstack:poteto-agent`, `poteto-mode/references/agents/comment-sicko.md` for `pstack:comment-sicko`, and the `thermo-nuclear-review` or `thermo-nuclear-code-quality-review` skill for the two reviewers.
 - `subagent_type: "general-purpose"` maps to `agent_type: "general-purpose"`. Where a skill leaves the type unset, use `pstack:poteto-agent`.
 - `readonly: true` (reviewers, explorers, critics) maps to a read-only agent type: `explore` for code reading, `code-review` for diff review. When a read-only role must run commands or reach MCP tools, use `general-purpose` and tell it in the prompt not to write files; review its diff anyway.
 - `readonly: false`, or a role that needs MCP tools, maps to `general-purpose` or `pstack:poteto-agent`.
@@ -120,7 +121,7 @@ Affected skill entry points point here. Most skills need only the tables above.
 | `swarm` | Workers are `task` calls with `mode: "background"`, each on its own worktree; in the app, `create_session` per worker. |
 | `teach` | Running `how` and `why` in parallel maps to `task` fan-out; image generation uses whatever image tool you have, or skip it and say so. |
 | `why` | Available MCP servers appear in your tool list; there is no `mcp__` prefix convention to scan for. |
-| `reflect` | Run `find-transcript.mjs <session-state directory> '<opening prompt fragment>' <workspace directory>` with the absolute session-state path under `${COPILOT_HOME:-~/.copilot}`. The workspace defaults to the current directory when omitted. The finder checks the session header's `cwd` against that workspace before reading Copilot's `user.message` records, so matching prompts in other projects are skipped. For a conversation in a related worktree, pass that worktree's directory explicitly. Reviewer references that name `.claude/skills/` and `${CLAUDE_CONFIG_DIR:-$HOME/.claude}/` paths mean the Copilot skill locations below. |
+| `reflect` | Run `find-transcript.mjs <session-state directory> '<opening prompt fragment>' <workspace directory>` with the absolute session-state path under `${COPILOT_HOME:-~/.copilot}`. That directory is outside the workspace, so the call takes the normal permission flow. The workspace defaults to the current directory when omitted. The finder checks the session header's `cwd` against that workspace before reading Copilot's `user.message` records, so matching prompts in other projects are skipped. For a conversation in a related worktree, pass that worktree's directory explicitly. Reviewer references that name `.claude/skills/` and `${CLAUDE_CONFIG_DIR:-$HOME/.claude}/` paths mean the Copilot skill locations below. |
 | `recall` | Search Copilot session state scoped to the current workspace (Transcripts above), not `${CLAUDE_CONFIG_DIR:-$HOME/.claude}/projects/`. |
 | `show-me-your-work` | The end-of-run check reads this session's `events.jsonl` (Transcripts above). |
 | `automate-me` | Mode skills live in the Copilot skill locations below; transcripts come from Transcripts above; `plugin-dev:skill-development` resolves through the skills table. |

package/plugins/pstack/skills/poteto-mode/references/pi-tools.md

@@ -54,7 +54,7 @@ Skills name models by the Claude aliases in their Models sections. On Pi, pass t
 | Alias | `anthropic` | `openai` | `openai-codex` |
 | --- | --- | --- | --- |
 | `opus` | `anthropic/claude-opus-5-5` | `openai/gpt-6.1-sol` | `openai-codex/gpt-6.1-sol` |
-| `fable` | `anthropic/claude-fable-5-1` | `openai/gpt-6-astra` | `openai-codex/gpt-6-astra` |
+| `fable` | `anthropic/claude-fable-5-2` | `openai/gpt-6-astra` | `openai-codex/gpt-6-astra` |
 | `sonnet` | `anthropic/claude-sonnet-5-5` | `openai/gpt-6.1-sol` | `openai-codex/gpt-6.1-sol` |
 | `haiku` | `anthropic/claude-haiku-5-5` | `openai/gpt-6-luna` | `openai-codex/gpt-6-luna` |
 

package/plugins/pstack/skills/poteto-mode/scripts/.prettierignore

@@ -1,10 +1,10 @@
 # Upstream's copies are not Prettier output, so formatting the port's copies
 # would add lines to the fork.
 bootstrap.ts
+watch-pr/policy.test.ts
 
 # The port added lines here that run past 80 columns; wrapping them grows the
 # forked-line count.
-watch-pr/policy.test.ts
 watch-pr/types.compile.ts
 
 # The check covers TypeScript. Upstream's check-plan.mjs uses tabs, and the

package/plugins/pstack/skills/poteto-mode/scripts/codex-session-effort.mjs

@@ -3,7 +3,7 @@
 // defaults, another thread, or a completed turn. Output contains no transcript.
 import { createReadStream, existsSync, readdirSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const levels = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"]);
@@ -40,20 +40,48 @@ export async function activeEffort(stream, threadId) {
   return effort;
 }
 
-export async function sessionEffort(threadId = process.env.CODEX_THREAD_ID, codexHome = process.env.CODEX_HOME) {
-  if (!threadId || !/^[a-zA-Z0-9_-]+$/.test(threadId)) throw new Error("CODEX_THREAD_ID is unavailable or invalid");
-  const root = join(codexHome || join(homedir(), ".codex"), "sessions");
+async function currentRollout(threadId, home) {
+  const databases = readdirSync(home).filter((name) => /^state_\d+\.sqlite$/.test(name));
+  if (databases.length > 1) throw new Error("current thread state database is ambiguous");
+  const sqlite = databases.length === 1 ? await import("node:sqlite").catch(() => null) : null;
+  if (sqlite) {
+    const db = new sqlite.DatabaseSync(join(home, databases[0]), { readOnly: true });
+    try {
+      const row = db.prepare("SELECT rollout_path FROM threads WHERE id = ?").get(threadId);
+      if (row) {
+        const path = row.rollout_path;
+        if (typeof path !== "string" || !isAbsolute(path) || !path.endsWith(".jsonl")) {
+          throw new Error("current thread runtime log is unavailable");
+        }
+        return path;
+      }
+    } finally {
+      db.close();
+    }
+  }
+
+  const root = join(home, "sessions");
   const matches = [];
+  const suffix = new RegExp(`-${threadId}(?:_[a-zA-Z0-9-]+)?\\.jsonl(?:\\.zst)?$`);
   const walk = (directory, depth = 0) => {
     for (const entry of readdirSync(directory, { withFileTypes: true })) {
       const path = join(directory, entry.name);
-      if (entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(`-${threadId}.jsonl`)) matches.push(path);
+      if (entry.isFile() && entry.name.startsWith("rollout-") && suffix.test(entry.name)) matches.push(path);
       else if (entry.isDirectory() && depth < 3) walk(path, depth + 1);
     }
   };
   walk(root);
-  if (matches.length !== 1) throw new Error("current thread runtime log is missing or ambiguous");
-  return activeEffort(createReadStream(matches[0], { encoding: "utf8" }), threadId);
+  if (matches.length !== 1 || !matches[0].endsWith(`-${threadId}.jsonl`)) {
+    throw new Error("current thread runtime log is missing or ambiguous");
+  }
+  return matches[0];
+}
+
+export async function sessionEffort(threadId = process.env.CODEX_THREAD_ID, codexHome = process.env.CODEX_HOME) {
+  if (!threadId || !/^[a-zA-Z0-9_-]+$/.test(threadId)) throw new Error("CODEX_THREAD_ID is unavailable or invalid");
+  const home = codexHome || join(homedir(), ".codex");
+  const path = await currentRollout(threadId, home);
+  return activeEffort(createReadStream(path, { encoding: "utf8" }), threadId);
 }
 
 if (process.argv[1] && existsSync(process.argv[1]) && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {

package/plugins/pstack/skills/poteto-mode/scripts/watch-pr/github.port.test.ts

@@ -0,0 +1,427 @@
+import { describe, expect, it } from "bun:test";
+import { WatchDeadline } from "./deadline.ts";
+import {
+  ChecksUnavailable,
+  WatcherQueryError,
+  discoverStack,
+  orderStack,
+  parseFastCheck,
+  parsePullRequest,
+  parseReviewThreadPage,
+  PR_FACTS_QUERY,
+  resolveChecks,
+  resolveContext,
+  resolveReviewThreads,
+  runJson,
+} from "./github.ts";
+import { fakeReader } from "./fakes.test-helper.ts";
+import type { PrContext } from "./types.ts";
+import { parsePrNumber } from "./types.ts";
+
+const context = {
+  owner: "owner",
+  repo: "repo",
+  number: parsePrNumber(42),
+};
+
+const numbers = (stack: readonly PrContext[]): number[] =>
+  stack.map((pr) => Number(pr.number));
+
+describe("checks fallback chain", () => {
+  it("reads no checks when gh reports none and the head commit has no rollup", async () => {
+    const reader = fakeReader({
+      fastPath: { kind: "none-reported" },
+      rollupPages: [{ kind: "no-rollup" }],
+    });
+    expect(await resolveChecks(reader, context)).toEqual({
+      kind: "no-checks",
+      checks: [],
+    });
+    expect(reader.calls).toEqual(["checksFastPath", "checkRollupPage:null"]);
+  });
+
+  it("fails closed when only one read says there are no checks", async () => {
+    const oneSided = [
+      {
+        fastPath: { kind: "unusable", exitCode: 1, stderr: "HTTP 401" },
+        rollupPages: [{ kind: "no-rollup" }],
+      },
+      {
+        fastPath: { kind: "checks", checks: [] },
+        rollupPages: [{ kind: "no-rollup" }],
+      },
+      {
+        fastPath: { kind: "none-reported" },
+        rollupPages: [{ kind: "contexts", checks: [], endCursor: null }],
+      },
+    ] as const;
+    for (const options of oneSided)
+      await expect(
+        resolveChecks(fakeReader(options), context)
+      ).rejects.toBeInstanceOf(ChecksUnavailable);
+  });
+
+  it("rejects a rollup cursor that does not advance instead of paging on", async () => {
+    const stuck = { kind: "contexts", checks: [], endCursor: "same" } as const;
+    const reader = fakeReader({
+      fastPath: { kind: "checks", checks: [] },
+      rollupPages: [
+        stuck,
+        stuck,
+        { kind: "contexts", checks: [], endCursor: null },
+      ],
+    });
+    await expect(resolveChecks(reader, context)).rejects.toMatchObject({
+      failure: {
+        kind: "missing-field",
+        retryable: true,
+        detail: expect.stringContaining("must advance"),
+      },
+    });
+    expect(reader.calls).toEqual([
+      "checksFastPath",
+      "checkRollupPage:null",
+      "checkRollupPage:same",
+    ]);
+  });
+
+  it("rejects a rollup cursor that returns to an earlier page after moving on", async () => {
+    const page = (endCursor: string | null) =>
+      ({ kind: "contexts", checks: [], endCursor }) as const;
+    const reader = fakeReader({
+      fastPath: { kind: "checks", checks: [] },
+      rollupPages: [page("a"), page("b"), page("a"), page(null)],
+    });
+    await expect(resolveChecks(reader, context)).rejects.toMatchObject({
+      failure: {
+        kind: "missing-field",
+        detail: expect.stringContaining("must advance"),
+      },
+    });
+    expect(reader.calls).toEqual([
+      "checksFastPath",
+      "checkRollupPage:null",
+      "checkRollupPage:a",
+      "checkRollupPage:b",
+    ]);
+  });
+
+  it("propagates a failed rollup query instead of reading it as no checks", async () => {
+    const reader = fakeReader({ fastPath: { kind: "none-reported" } });
+    const failure = new WatcherQueryError({
+      kind: "command-exit",
+      retryable: true,
+      code: 1,
+      detail: "HTTP 502",
+    });
+    reader.checkRollupPage = async () => {
+      throw failure;
+    };
+    await expect(resolveChecks(reader, context)).rejects.toBe(failure);
+  });
+});
+
+it("reports a binary that cannot be spawned as a query failure that does not retry", async () => {
+  await expect(
+    runJson(
+      ["/nonexistent/watch-pr-missing-gh", "pr", "view"],
+      new WatchDeadline(0, () => 0)
+    )
+  ).rejects.toMatchObject({
+    failure: {
+      kind: "spawn-failed",
+      retryable: false,
+      detail: expect.stringContaining("ENOENT"),
+    },
+  });
+});
+
+describe("fast-path check mapping", () => {
+  // gh's aggregate.go files every state it does not name into the pending
+  // bucket, including completed conclusions.
+  it("fails completed conclusions that gh buckets as pending", () => {
+    for (const state of ["STARTUP_FAILURE", "STALE"]) {
+      expect(
+        parseFastCheck({ name: "ci", state, bucket: "pending" })
+      ).toMatchObject({ kind: "failed", reportedState: state });
+    }
+  });
+
+  it("keeps in-flight states pending", () => {
+    for (const state of [
+      "EXPECTED",
+      "REQUESTED",
+      "WAITING",
+      "QUEUED",
+      "PENDING",
+      "IN_PROGRESS",
+    ]) {
+      expect(
+        parseFastCheck({ name: "ci", state, bucket: "pending" })
+      ).toMatchObject({ kind: "pending", reportedState: state });
+    }
+  });
+});
+
+describe("closed enum parsing", () => {
+  const rawPullRequest = {
+    mergeable: "MERGEABLE",
+    mergeStateStatus: "CLEAN",
+    reviewDecision: "APPROVED",
+    headRefOid: "head",
+    baseRef: { target: { oid: "base" } },
+    headRefName: "feature",
+    baseRefName: "main",
+    state: "OPEN",
+    mergedAt: null,
+    isDraft: false,
+  };
+
+  it("uses the current base target when the scalar base OID is stale", () => {
+    expect(
+      parsePullRequest(
+        {
+          ...rawPullRequest,
+          baseRefOid: "stale-base",
+          baseRef: { target: { oid: "current-base" } },
+        },
+        context
+      ).baseRefOid
+    ).toBe("current-base");
+  });
+
+  it("queries the current base target with the other PR facts", () => {
+    expect(PR_FACTS_QUERY).toContain("baseRef { target { oid } }");
+    expect(PR_FACTS_QUERY).not.toContain("baseRefOid");
+  });
+
+  it("fails closed when the current base ref is null or missing", () => {
+    const missingBaseRef = Object.fromEntries(
+      Object.entries(rawPullRequest).filter(([key]) => key !== "baseRef")
+    );
+    for (const value of [{ ...rawPullRequest, baseRef: null }, missingBaseRef])
+      expect(() => parsePullRequest(value, context)).toThrow(WatcherQueryError);
+  });
+});
+
+describe("review thread pagination", () => {
+  it("rejects a page that promises more pages without a cursor", () => {
+    for (const endCursor of [null, ""]) {
+      const response = {
+        data: {
+          repository: {
+            pullRequest: {
+              reviewThreads: {
+                pageInfo: { hasNextPage: true, endCursor },
+                nodes: [],
+              },
+            },
+          },
+        },
+      };
+      expect(() => parseReviewThreadPage(response)).toThrow(WatcherQueryError);
+    }
+  });
+
+  it("rejects a thread cursor that does not advance instead of paging on", async () => {
+    const stuck = { threads: [], endCursor: "same" };
+    const reader = fakeReader({
+      threadPages: [stuck, stuck, { threads: [], endCursor: null }],
+    });
+    await expect(resolveReviewThreads(reader, context)).rejects.toMatchObject({
+      failure: {
+        kind: "missing-field",
+        retryable: true,
+        detail: expect.stringContaining(
+          "reviewThreads.pageInfo.endCursor must advance"
+        ),
+      },
+    });
+    expect(reader.calls).toEqual([
+      "reviewThreadPage:null",
+      "reviewThreadPage:same",
+    ]);
+  });
+});
+
+describe("context and stack discovery", () => {
+  it("refuses to pair the checkout's PR number with a different explicit repository", async () => {
+    const reader = fakeReader({
+      current: { owner: "acme", repo: "web", number: parsePrNumber(57) },
+    });
+    const resolved = resolveContext({
+      reader,
+      owner: "acme",
+      repo: "api",
+      pr: null,
+    });
+    await expect(resolved).rejects.toBeInstanceOf(WatcherQueryError);
+    await expect(resolved).rejects.toMatchObject({
+      failure: { retryable: false },
+    });
+  });
+
+  it("accepts an explicit repository that matches the checkout's PR", async () => {
+    const reader = fakeReader({
+      current: { owner: "acme", repo: "web", number: parsePrNumber(57) },
+    });
+    expect(
+      await resolveContext({ reader, owner: "ACME", repo: "Web", pr: null })
+    ).toEqual({ owner: "ACME", repo: "Web", number: parsePrNumber(57) });
+  });
+
+  it("keeps a PR whose head is the default branch out of every stack", () => {
+    const repo = { owner: "owner", repo: "repo" };
+    const backport = parsePrNumber(2);
+    const open = [
+      {
+        number: backport,
+        headRepository: repo,
+        headRefName: "main",
+        baseRefName: "release",
+      },
+      {
+        number: context.number,
+        headRepository: repo,
+        headRefName: "feature",
+        baseRefName: "main",
+      },
+      {
+        number: parsePrNumber(43),
+        headRepository: repo,
+        headRefName: "upstack",
+        baseRefName: "feature",
+      },
+    ];
+    expect(numbers(orderStack(context, "main", open))).toEqual([42, 43]);
+    expect(
+      numbers(orderStack({ ...context, number: backport }, "main", open))
+    ).toEqual([2]);
+  });
+
+  it("keeps a PR that brings the default branch into a feature branch out of that feature's stack", () => {
+    const repo = { owner: "owner", repo: "repo" };
+    const sync = parsePrNumber(7);
+    const open = [
+      {
+        number: context.number,
+        headRepository: repo,
+        headRefName: "feature",
+        baseRefName: "main",
+      },
+      {
+        number: sync,
+        headRepository: repo,
+        headRefName: "main",
+        baseRefName: "feature",
+      },
+    ];
+    expect(numbers(orderStack(context, "main", open))).toEqual([42]);
+    expect(
+      numbers(orderStack({ ...context, number: sync }, "main", open))
+    ).toEqual([7]);
+  });
+
+  it("still stacks a fork PR whose head branch has the default branch's name", () => {
+    const fork = parsePrNumber(50);
+    const open = [
+      {
+        number: context.number,
+        headRepository: { owner: "owner", repo: "repo" },
+        headRefName: "feature",
+        baseRefName: "main",
+      },
+      {
+        number: fork,
+        headRepository: { owner: "contributor", repo: "repo" },
+        headRefName: "main",
+        baseRefName: "feature",
+      },
+    ];
+    expect(numbers(orderStack(context, "main", open))).toEqual([42, 50]);
+    expect(
+      numbers(orderStack({ ...context, number: fork }, "main", open))
+    ).toEqual([42, 50]);
+  });
+
+  it("stops at the default branch when it is an integration branch with a release PR", () => {
+    const repo = { owner: "owner", repo: "repo" };
+    const open = [
+      {
+        number: parsePrNumber(500),
+        headRepository: repo,
+        headRefName: "develop",
+        baseRefName: "main",
+      },
+      {
+        number: parsePrNumber(612),
+        headRepository: repo,
+        headRefName: "feature/login",
+        baseRefName: "develop",
+      },
+      {
+        number: parsePrNumber(613),
+        headRepository: repo,
+        headRefName: "fix/typo",
+        baseRefName: "develop",
+      },
+    ];
+    expect(
+      numbers(
+        orderStack({ ...repo, number: parsePrNumber(612) }, "develop", open)
+      )
+    ).toEqual([612]);
+    expect(
+      numbers(
+        orderStack({ ...repo, number: parsePrNumber(500) }, "develop", open)
+      )
+    ).toEqual([500]);
+  });
+
+  it("reads the default branch once while discovering a stack", async () => {
+    const reader = fakeReader({ defaultBranch: "trunk" });
+    expect(await discoverStack(reader, context)).toEqual([context]);
+    expect(reader.calls).toEqual(["openPullRequests", "defaultBranch"]);
+  });
+
+  it("orders a discovered stack around the default branch the repository reports", async () => {
+    const repo = { owner: "owner", repo: "repo" };
+    const reader = fakeReader({
+      defaultBranch: "develop",
+      openPullRequests: [
+        {
+          number: parsePrNumber(500),
+          headRepository: repo,
+          headRefName: "develop",
+          baseRefName: "main",
+        },
+        {
+          number: context.number,
+          headRepository: repo,
+          headRefName: "feature",
+          baseRefName: "develop",
+        },
+      ],
+    });
+    expect(numbers(await discoverStack(reader, context))).toEqual([42]);
+  });
+
+  it("refuses a full open-PR page, which may have cut the stack", async () => {
+    const openPrs = (count: number) =>
+      Array.from({ length: count }, (_, index) => ({
+        number: parsePrNumber(index + 1),
+        headRepository: { owner: "owner", repo: "repo" },
+        headRefName: `branch-${index + 1}`,
+        baseRefName: "main",
+      }));
+    await expect(
+      discoverStack(fakeReader({ openPullRequests: openPrs(300) }), context)
+    ).rejects.toMatchObject({ failure: { kind: "invalid-stack" } });
+    expect(
+      await discoverStack(
+        fakeReader({ openPullRequests: openPrs(299) }),
+        context
+      )
+    ).toEqual([context]);
+  });
+});