@plainconceptsplatform/workflows 0.4.28 → 0.4.32

package/dist/catalog-installation.d.ts

@@ -21,6 +21,8 @@ export declare function catalogSourcePath(modulePath?: string): string;
 export declare function installCatalog(repositoryPath: string, options?: CatalogInstallOptions): Promise<CatalogInstallResult>;
 export declare function installTemplate(repositoryPath: string, template: TemplateName, options?: CatalogInstallOptions): Promise<CatalogInstallResult>;
 export declare function installMandatoryFiles(repositoryPath: string, options?: CatalogInstallOptions): Promise<CatalogInstallResult>;
+export declare function installedRoutes(repositoryPath: string): Promise<RouteName[]>;
+export declare function removeRouteFiles(repositoryPath: string, routes: readonly RouteName[]): Promise<string[]>;
 export declare function isTemplateName(value: string): value is TemplateName;
 export declare function ensurePreCommitHook(repositoryPath: string): Promise<void>;
 export declare function runCompileIfAvailable(repositoryPath: string): Promise<void>;

package/dist/catalog-installation.js

@@ -4,7 +4,7 @@ import { constants } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import { catalogTemplates, mandatoryFiles, routeNames, templateNames } from "./workflow-catalog.js";
+import { catalogTemplates, mandatoryFiles, routeNames, templateNames, workflowRoutes } from "./workflow-catalog.js";
 import { processRoutes, excludedWorkerFiles } from "./route-processing.js";
 import { generateOpencodeCi, generateOpencodeConfig, generateStackDefaults, injectStackEnv } from "./stack-defaults.js";
 const execFileAsync = promisify(execFile);
@@ -149,6 +149,28 @@ export async function installMandatoryFiles(repositoryPath, options = {}) {
     await applyTransaction(repositoryPath, [...updates, await preCommitHookUpdate(repositoryPath)]);
     return { installed: files.map((file) => file.target), conflicts };
 }
+export async function installedRoutes(repositoryPath) {
+    const found = await Promise.all(workflowRoutes.map(async (route) => (await exists(join(repositoryPath, ".github", "workflows", route.worker))) ? route.name : undefined));
+    return found.filter((name) => name !== undefined);
+}
+export async function removeRouteFiles(repositoryPath, routes) {
+    const workerByRoute = new Map(workflowRoutes.map((route) => [route.name, route.worker]));
+    const removed = [];
+    for (const route of routes) {
+        const worker = workerByRoute.get(route);
+        if (worker === undefined)
+            continue;
+        const lock = worker.replace(/\.md$/, ".lock.yml");
+        for (const file of [worker, lock]) {
+            const destination = join(repositoryPath, ".github", "workflows", file);
+            if (await exists(destination)) {
+                await rm(destination, { force: true });
+                removed.push(`.github/workflows/${file}`);
+            }
+        }
+    }
+    return removed.sort();
+}
 export function isTemplateName(value) {
     return templateNames.includes(value);
 }

package/dist/catalog-installation.test.js

@@ -3,7 +3,7 @@ import { constants } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
-import { catalogSourcePath, ensurePreCommitHook, installCatalog, installMandatoryFiles, installTemplate } from "./catalog-installation.js";
+import { catalogSourcePath, ensurePreCommitHook, installCatalog, installedRoutes, installMandatoryFiles, installTemplate, removeRouteFiles } from "./catalog-installation.js";
 const temporaryDirectories = [];
 afterEach(async () => {
     await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { force: true, recursive: true })));
@@ -385,6 +385,36 @@ describe("catalog installation", () => {
         });
     });
 });
+describe("route lifecycle", () => {
+    it("detects installed route workers in workflowRoutes order", async () => {
+        const repositoryPath = await createDirectory({
+            ".github/workflows/agent-implement.md": "# Implement\n",
+            ".github/workflows/agent-refine.md": "# Refine\n",
+        });
+        await expect(installedRoutes(repositoryPath)).resolves.toEqual(["refine", "implement"]);
+    });
+    it("returns an empty list when no route workers are installed", async () => {
+        const repositoryPath = await createDirectory({});
+        await expect(installedRoutes(repositoryPath)).resolves.toEqual([]);
+    });
+    it("removes a route worker and its generated lock, leaving other workers", async () => {
+        const repositoryPath = await createDirectory({
+            ".github/workflows/agent-refine.md": "# Refine\n",
+            ".github/workflows/agent-refine.lock.yml": "generated\n",
+            ".github/workflows/agent-implement.md": "# Implement\n",
+        });
+        await expect(removeRouteFiles(repositoryPath, ["refine"])).resolves.toEqual([
+            ".github/workflows/agent-refine.lock.yml",
+            ".github/workflows/agent-refine.md",
+        ]);
+        await expect(readFile(join(repositoryPath, ".github/workflows/agent-refine.md"), "utf8")).rejects.toThrow();
+        await expect(readFile(join(repositoryPath, ".github/workflows/agent-implement.md"), "utf8")).resolves.toBe("# Implement\n");
+    });
+    it("ignores routes that are not installed", async () => {
+        const repositoryPath = await createDirectory({});
+        await expect(removeRouteFiles(repositoryPath, ["propose"])).resolves.toEqual([]);
+    });
+});
 async function createDirectory(files) {
     const directory = await mkdtemp(join(tmpdir(), "workflows-"));
     temporaryDirectories.push(directory);

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { inspectRepository, parseVisibility, resolveVisibility } from "./repository-inspection.js";
-import { installCatalog, installTemplate, isTemplateName } from "./catalog-installation.js";
+import { installCatalog, installedRoutes, installTemplate, isTemplateName, removeRouteFiles } from "./catalog-installation.js";
 import { formatCatalog, listCatalog, searchCatalog } from "./catalog-listing.js";
 import { routeNames, templateNames } from "./workflow-catalog.js";
 import { runInteractive } from "./tui.js";
@@ -21,6 +21,7 @@ Commands:
   (default)                                   Launch the interactive TUI for selecting and installing items.
   init                                        Inspect the repository and report its stack and visibility.
   add [routes] [--template <name>] [--force]  Install route workers, a template, or mandatory files.
+  remove <routes> [--force]                   Uninstall route workers and regenerate the router without them.
   update                                      Alias for add.
   status                                      Print repository inspection as JSON.
   list                                        List all available workflows and templates with install status.
@@ -35,6 +36,12 @@ Route names (positional arguments to add):
   add --template agentics-checks             Installs the named template only (no mandatory files).
   add refine --template agentics-checks      Installs routes + mandatory + the named template.
   add refine implement --force               Forces re-install of routes plus mandatory, overwriting.
+  remove propose                             Uninstalls the propose worker and drops it from the router.
+
+add and remove keep the router consistent with what is installed: add unions the requested
+routes with the routes already present, and remove drops the requested routes from that set.
+Both regenerate the router, classifier, and route matrix from the resulting set. Changing the
+route set rewrites the package-owned router, so pass --force to overwrite it.
 
 Options:
   --visibility public|private                 Override repository visibility (init only).
@@ -95,7 +102,8 @@ export async function run(arguments_, repositoryPath = process.cwd()) {
         const allConflicts = [];
         const allInstalled = [];
         if (routes.length > 0) {
-            const result = await installCatalog(repositoryPath, { force, selectedRoutes: routes, inspection });
+            const selectedRoutes = unionRoutes(routes, await installedRoutes(repositoryPath));
+            const result = await installCatalog(repositoryPath, { force, selectedRoutes, inspection });
             allConflicts.push(...result.conflicts);
             allInstalled.push(...result.installed);
         }
@@ -116,8 +124,36 @@ export async function run(arguments_, repositoryPath = process.cwd()) {
         console.log(JSON.stringify({ command, installed: allInstalled.sort(), conflicts: allConflicts }, null, 2));
         return 0;
     }
+    if (command === "remove") {
+        const parsed = parseAddOptions(options);
+        if (parsed.kind === "invalid")
+            return fail(parsed.message);
+        if (parsed.template !== undefined)
+            return fail("remove does not accept --template.");
+        if (parsed.routes.length === 0)
+            return fail("remove requires at least one route.");
+        const inspection = await inspectRepository(repositoryPath);
+        const installed = await installedRoutes(repositoryPath);
+        const desiredRoutes = installed.filter((route) => !parsed.routes.includes(route));
+        const result = await installCatalog(repositoryPath, { force: parsed.force, selectedRoutes: desiredRoutes, inspection });
+        if (result.conflicts.length > 0 && !parsed.force) {
+            console.error(`Catalog conflicts found. Re-run with --force to overwrite package-managed files:\n${result.conflicts.join("\n")}`);
+            return 1;
+        }
+        const removed = await removeRouteFiles(repositoryPath, parsed.routes);
+        console.log(JSON.stringify({ command, installed: [...result.installed].sort(), removed, conflicts: result.conflicts }, null, 2));
+        return 0;
+    }
     return fail(`Unknown command: ${command}`);
 }
+function unionRoutes(requested, installed) {
+    const result = [...requested];
+    for (const route of installed) {
+        if (!result.includes(route))
+            result.push(route);
+    }
+    return result;
+}
 function readVisibilityOption(options) {
     if (options.length === 0)
         return undefined;

package/dist/index.test.js

@@ -219,6 +219,46 @@ describe("workflows CLI", () => {
         expect(error).toHaveBeenCalledWith("Unknown option: --unknown");
         error.mockRestore();
     });
+    it("add unions requested routes with already-installed routes", async () => {
+        const { installCatalog } = mockInstallers();
+        const repositoryPath = await createRepository({
+            ".github/workflows/agent-refine.md": "# Refine",
+            ".github/workflows/agent-implement.md": "# Implement",
+        });
+        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        await expect(run(["add", "direct"], repositoryPath)).resolves.toBe(0);
+        expect(installCatalog).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ selectedRoutes: ["direct", "refine", "implement"] }));
+        log.mockRestore();
+    });
+    it("remove requires at least one route", async () => {
+        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        await expect(run(["remove"])).resolves.toBe(1);
+        expect(error).toHaveBeenCalledWith("remove requires at least one route.");
+        error.mockRestore();
+    });
+    it("remove rejects the --template flag", async () => {
+        const error = vi.spyOn(console, "error").mockImplementation(() => undefined);
+        await expect(run(["remove", "--template", "agentics-checks"])).resolves.toBe(1);
+        expect(error).toHaveBeenCalledWith("remove does not accept --template.");
+        error.mockRestore();
+    });
+    it("remove regenerates the router for the remaining routes and deletes the worker", async () => {
+        const { installCatalog } = mockInstallers();
+        const repositoryPath = await createRepository({
+            ".github/workflows/agent-refine.md": "# Refine",
+            ".github/workflows/agent-refine.lock.yml": "generated",
+            ".github/workflows/agent-implement.md": "# Implement",
+        });
+        const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+        await expect(run(["remove", "refine", "--force"], repositoryPath)).resolves.toBe(0);
+        expect(installCatalog).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ force: true, selectedRoutes: ["implement"] }));
+        const { access } = await import("node:fs/promises");
+        const { constants } = await import("node:fs");
+        await expect(access(join(repositoryPath, ".github/workflows/agent-refine.md"), constants.F_OK)).rejects.toThrow();
+        await expect(access(join(repositoryPath, ".github/workflows/agent-refine.lock.yml"), constants.F_OK)).rejects.toThrow();
+        await expect(access(join(repositoryPath, ".github/workflows/agent-implement.md"), constants.F_OK)).resolves.toBeUndefined();
+        log.mockRestore();
+    });
 });
 async function createRepository(files) {
     const repositoryPath = await mkdtemp(join(tmpdir(), "workflows-"));

package/dist/tui.js

@@ -1,6 +1,6 @@
 import * as readline from "node:readline";
 import { formatCatalog, listCatalog } from "./catalog-listing.js";
-import { installCatalog, installMandatoryFiles, installTemplate, isTemplateName } from "./catalog-installation.js";
+import { installCatalog, installMandatoryFiles, installTemplate, isTemplateName, removeRouteFiles } from "./catalog-installation.js";
 import { inspectRepository } from "./repository-inspection.js";
 import { routeNames } from "./workflow-catalog.js";
 const ANSI = {
@@ -218,22 +218,37 @@ export async function runInteractive(repositoryPath, options = {}) {
 }
 async function installSelected(state, repositoryPath, force) {
     const items = getItemsToInstall(state, force);
-    const routes = items.filter((entry) => entry.kind === "route");
+    const newRoutes = items.filter((entry) => entry.kind === "route");
     const templates = items.filter((entry) => entry.kind === "template");
+    const routeEntries = state.allItems.filter((entry) => entry.kind === "route");
+    const checkedRoutes = routeEntries
+        .filter((entry) => state.selected.has(entry.name))
+        .map((entry) => entry.name)
+        .filter((name) => routeNames.includes(name));
+    const installedRouteNames = routeEntries
+        .filter((entry) => entry.installed)
+        .map((entry) => entry.name)
+        .filter((name) => routeNames.includes(name));
+    const removedRoutes = installedRouteNames.filter((name) => !checkedRoutes.includes(name));
     const allConflicts = [];
     const allInstalled = [];
-    const selectedRouteNames = routes.length > 0
-        ? routes.map((entry) => entry.name).filter((name) => routeNames.includes(name))
-        : [...routeNames];
+    const allRemoved = [];
     const inspection = await inspectRepository(repositoryPath);
-    if (routes.length > 0) {
-        const result = await installCatalog(repositoryPath, {
-            force,
-            selectedRoutes: selectedRouteNames,
-            inspection,
-        });
+    if (checkedRoutes.length > 0 && (newRoutes.length > 0 || removedRoutes.length > 0 || force)) {
+        const result = await installCatalog(repositoryPath, { force, selectedRoutes: checkedRoutes, inspection });
         allConflicts.push(...result.conflicts);
         allInstalled.push(...result.installed);
+        if (result.conflicts.length === 0 || force) {
+            allRemoved.push(...await removeRouteFiles(repositoryPath, removedRoutes));
+        }
+    }
+    else if (checkedRoutes.length === 0 && removedRoutes.length > 0) {
+        const result = await installCatalog(repositoryPath, { force, selectedRoutes: [], inspection });
+        allConflicts.push(...result.conflicts);
+        allInstalled.push(...result.installed);
+        if (result.conflicts.length === 0 || force) {
+            allRemoved.push(...await removeRouteFiles(repositoryPath, removedRoutes));
+        }
     }
     else {
         const result = await installMandatoryFiles(repositoryPath, { force });
@@ -251,10 +266,18 @@ async function installSelected(state, repositoryPath, force) {
         console.error(`Conflicts found. Re-run with --force to overwrite:\n${allConflicts.join("\n")}`);
         return 1;
     }
-    if (allInstalled.length > 0) {
-        console.log(`Installed ${allInstalled.length} item(s):`);
-        for (const file of allInstalled) {
-            console.log(`  ${file}`);
+    if (allInstalled.length > 0 || allRemoved.length > 0) {
+        if (allInstalled.length > 0) {
+            console.log(`Installed ${allInstalled.length} item(s):`);
+            for (const file of allInstalled) {
+                console.log(`  ${file}`);
+            }
+        }
+        if (allRemoved.length > 0) {
+            console.log(`Removed ${allRemoved.length} item(s):`);
+            for (const file of allRemoved) {
+                console.log(`  ${file}`);
+            }
         }
     }
     else {

package/loops/actions/classify-route/classify-route.sh

@@ -11,8 +11,7 @@ set -euo pipefail
 readonly AUDIT_CRON="17 1 * * 1"
 readonly AUDIT_CLOSE_CRON="43 3 * * *"
 readonly CLEANUP_ARTIFACTS_CRON="0 6 * * *"
-readonly RECONCILE_BOT_PR_RUNS_CRON="*/15 * * * *"
-readonly STALE_RECOVERY_CRON="0 */2 * * *"
+readonly RECONCILE_BOT_PR_RUNS_CRON="*/30 * * * *"
 # Daily, but it proposes far less often than daily: the worker holds one open
 # proposal at a time and skips while that slot is filled. The cron is a heartbeat,
 # the queue is the pacing.
@@ -136,8 +135,6 @@ classify_route() {
         "$AUDIT_CLOSE_CRON") route="audit-close" ;;
         "$CLEANUP_ARTIFACTS_CRON") route="cleanup-artifacts" ;;
         "$RECONCILE_BOT_PR_RUNS_CRON") route="reconcile-bot-pr-runs" ;;
-        "$STALE_RECOVERY_CRON") route="stale-recovery" ;;
-        "$PROPOSE_CRON") route="propose" ;;
         *) error="no route for cron '${SCHEDULE:-}'" ;;
       esac
       ;;
@@ -180,7 +177,7 @@ classify_route() {
           route="${OPERATION}"
           trigger_kind="${INPUT_TRIGGER_KIND:-manual}"
           ;;
-        audit-close | cleanup-artifacts | reconcile-bot-pr-runs | stale-recovery | validate)
+          audit-close | cleanup-artifacts | reconcile-bot-pr-runs | validate)
           route="${OPERATION}"
           ;;
         *)

package/loops/workflows/agent-implement.md

@@ -277,14 +277,35 @@ timeout-minutes: 90
      If a check fails, fix the cause and rerun. Do not weaken a test, lower a threshold, or skip
      a check to make it pass.
 
-  5. Before creating the pull request, update `changelog.json` in the project's
-     `src/shared/data/` folder (create `src/shared/data/changelog.json` if it does not
-     exist; in a monorepo use `apps/web/src/shared/data/changelog.json`). The file
-     has shape `{"version":1,"changes":[...]}`. Use `jq` to prepend a new entry
-     with `"timestamp"` (ISO 8601), `"issue"` (number), `"title"` (issue title),
-     `"summary"` (1-2 sentences of what you changed), and `"commit"` (short SHA).
-     Keep at most 10 entries: if there are already 10, drop the oldest. Commit
-     this file as part of the same branch before creating the PR.
+   5. Before creating the pull request, check whether an open bot pull request already
+      exists that closes #${{ inputs.issue-number }}. Run:
+
+      ```
+      gh pr list --repo "$GITHUB_REPOSITORY" --state open --search "is:pr linked:issue ${{ inputs.issue-number }}" --json number,headRefName,author --jq '[.[] | select(.author.login | test("[bot]$"))] | if length > 0 then .[0] else empty end'
+      ```
+
+      If a PR already exists, do **not** create a new branch or PR. Push your changes to
+      the existing PR's branch (`headRefName`) instead, then call
+      `safeoutputs/push_to_pull_request_branch` rather than `safeoutputs/create_pull_request`.
+      This prevents duplicate PRs when a retry is triggered after a merge-gate failure.
+
+      If no existing PR is found, proceed to create a new one as described below.
+
+      Before creating the pull request, update `changelog.json` in the project's
+      `src/shared/data/` folder (create `src/shared/data/changelog.json` if it does not
+      exist; in a monorepo use `apps/web/src/shared/data/changelog.json`). The file
+      has shape `{"version":1,"changes":[...]}`. Use `jq` to prepend a new entry
+      with `"timestamp"` (ISO 8601), `"issue"` (number), `"title"` (issue title),
+      `"summary"` (1-2 sentences of what you changed), and `"commit"` (short SHA).
+      Keep at most 10 entries: if there are already 10, drop the oldest. Commit
+      this file as part of the same branch before creating the PR.
+
+      The changelog is user-facing. Write the summary for a non-technical reader. Never
+      expose security, auth, or admin internals: no token/session/JWT details, no
+      permission or authorization logic, no audit trail mechanics, no internal method
+      names, no database or migration details. If the work touches these areas, describe
+      the user-visible outcome only (e.g. "Improved session reliability" or "Fixed a data
+      display issue"), not how it was implemented.
 
   6. You **must** call exactly one safe-output tool before finishing, or the workflow
     reports a failure. All safe-output tools are on the `safeoutputs` MCP server. Call
@@ -296,11 +317,14 @@ timeout-minutes: 90
 
     Choose exactly one:
 
-     - **`safeoutputs/create_pull_request`** , propose a pull request against `main` with
-       the verified changes. Its `body` must close the issue
-       (`Closes #${{ inputs.issue-number }}`) and summarise what changed and why.
-      This is the normal path.
-    - **`safeoutputs/report_incomplete`** , use only when infrastructure or tooling
+      - **`safeoutputs/create_pull_request`** , propose a pull request against `main` with
+        the verified changes. Its `body` must close the issue
+        (`Closes #${{ inputs.issue-number }}`) and summarise what changed and why.
+        Use this when no open bot PR exists for the issue.
+       This is the normal path.
+      - **`safeoutputs/push_to_pull_request_branch`** , push to an existing PR's branch
+        when step 5 found an open bot PR for this issue. Do not create a duplicate PR.
+      - **`safeoutputs/report_incomplete`** , use only when infrastructure or tooling
       prevents you from completing the task (e.g. the codebase cannot build due to a
       pre-existing error you cannot fix). Provide a specific `reason`.
     - **`safeoutputs/noop`** , use only when the issue context shows the work is already

package/loops/workflows/agent-merge-gate.md

@@ -270,7 +270,7 @@ jobs:
         with:
           token: ${{ steps.app-token.outputs.token }}
           issue-number: ${{ needs.subject.outputs.issue }}
-          labels: ${{ env.WORKING_LABEL }}
+          labels: ${{ env.WORKING_LABEL }},${{ env.IMPLEMENT_LABEL }}
       - name: Flag for human review
         uses: ./.github/actions/add-issue-labels
         with:
@@ -442,8 +442,8 @@ timeout-minutes: 60
    stop looping: `remove_labels` (item_number: ${{ needs.subject.outputs.issue }}) to remove
    `implement` and `bot-working`, `add_labels` (item_number:
    ${{ needs.subject.outputs.issue }}) to add `review`, and `add_comment` (item_number:
-   ${{ needs.subject.outputs.issue }}) with the failure and what you tried. Per #167
-   decision 2, a human decides from there.
+   ${{ needs.subject.outputs.issue }}) with the failure and what you tried. The `implement`
+   label is removed so retries do not create duplicate PRs. A human decides from there.
 
 8. Never merge with administrator privileges and never bypass a required check. If the merge
    is refused, that refusal is the answer: `add_labels` to add `review`

package/loops/workflows/agent-refine.md

@@ -10,6 +10,7 @@ env:
   REFINE_MARKER: "<!-- agent-refine -->"
   INITIAL_MODE: first
   RESPONSE_MODE: rerefine
+  MAX_SELF_QUESTIONS: "5"
   INCOMPLETE_COMMENT: "Automated refinement ended without an outcome. The refine label remains for a retry."
   SAFE_OUTPUT_COMMENT_PREFIX: "Refinement update"
   ISSUE_CONTEXT_PATH: /tmp/gh-aw/agent/issue-context.json
@@ -24,6 +25,10 @@ description: |
   Refines an issue into a user story, on a first pass or after the author has answered the
   bot's questions. Replaces .loops/recipes/refine-loop.yaml.
 
+  Before writing the story, the agent explores the codebase per work unit (each bullet in a
+  bullet-list issue is its own unit), answering its own questions where the code can and
+  escalating only genuine business decisions to the author.
+
   Each issue refines independently. `bot-working` prevents double-processing: the reserve
   job adds it, the agent or finalization removes it, and a crashed run's leftover marker
   still parks an issue for a person.
@@ -234,9 +239,9 @@ engine:
     - "plainconcepts/glm-5-2"
 
 model: openai/glm-5-2
-max-turns: 300
-max-turn-cache-misses: 3000
-max-ai-credits: 5000
+max-turns: 500
+max-turn-cache-misses: 4000
+max-ai-credits: 8000
 
 permissions: read-all
 
@@ -256,7 +261,7 @@ safe-outputs:
   add-comment:
 
 
-timeout-minutes: 30
+timeout-minutes: 40
 ---
 
 1. You are refining the triggering issue **#${{ inputs.issue-number }}**. Do not choose
@@ -270,31 +275,66 @@ timeout-minutes: 30
    - On a `${{ env.RESPONSE_MODE }}` pass, incorporate only the supplied answers from the issue author or an
      assignee. Do not use answers from other commenters.
 
-3. Call skill("ob-plan-story"), then run `/plan-story` for the issue. Ground the story in the actual
-   codebase by reading the relevant files. Never read outside this repository root. Write it as
-   a user story in Mike Cohn's As a / I want to / so that form, with
-   Given/When/Then acceptance criteria, the edge cases, and a Mermaid diagram where one
-   genuinely helps.
+3. Explore before you write. Call skill("ob-plan-explore") and hold its stance for this step:
+   read-only, no plans, no files, no branches. You are only building understanding here, never
+   producing artifacts.
+
+   Split the issue into work units first. If the issue body is a bullet list of distinct tasks
+   (for example "- check the button component", "- then check the login", "- then suggest a
+   register page"), treat each bullet as its own work unit. Otherwise treat the whole issue as a
+   single work unit.
+
+   Create a todo entry for each work unit before you start exploring. Process them one at a
+   time, strictly sequentially: explore unit 1, self-answer its questions, mark the todo
+   complete, then move to unit 2. Do not explore multiple work units in the same pass. Do not
+   start unit N+1 until unit N is marked complete.
+
+   For the current work unit only:
+   - Explore the relevant code and repository documentation, and raise the concrete questions you
+     must answer to refine it well.
+   - Keep exploring to answer those questions yourself from the codebase and the docs.
+   - Only when a question is a genuine business or product decision that the code cannot answer,
+     set it aside as a question for the author.
+   - Mark the unit's todo complete only when your findings are concrete enough to write
+     acceptance criteria for this unit. If you explored a file but cannot describe what changes
+     for this unit, you are not done — keep exploring or set aside a question.
+
+   Explore more deeply than a single pass, but never without end. Ask yourself at most
+   ${{ env.MAX_SELF_QUESTIONS }} questions per work unit, and stop once further exploration no
+   longer changes your understanding. This exploration is internal working: never write your
+   self-asked questions or their answers to the issue.
+
+4. Before writing the story, verify coverage: list every work unit and confirm each one has
+   exploration findings concrete enough for acceptance criteria. If any unit is missing, go back
+   and explore it now. Then call skill("ob-plan-story") and run `/plan-story` for the issue,
+   passing everything you learned while exploring as the exploration findings. Ground the story
+   in the actual codebase by reading the relevant files. Never read outside this repository root.
+   When the issue held several work units, combine them into a single user story that covers all
+   of them. Write at least one Given/When/Then acceptance scenario per work unit. Write it as a
+   user story in Mike Cohn's As a / I want to / so that form, with Given/When/Then acceptance
+   criteria, the edge cases, and a Mermaid diagram where one genuinely helps.
 
      Apply repository documentation and established conventions before finalizing the story.
      Adhere to ${{ env.REPO_RULES }}.
 
- 4. Load `@humanizer` and prepare the complete replacement issue body as valid Markdown.
+5. Load `@humanizer` and prepare the complete replacement issue body as valid Markdown.
 
-5. Decide exactly one outcome:
+6. Decide exactly one outcome:
 
     Labels are workflow-owned state. Do not call `add_labels` or `remove_labels`.
 
-    **Questions remain.** Leave the body unchanged. Call `add_comment` once with:
+    **Questions remain.** You set aside one or more questions for the author that the codebase
+    could not answer. Leave the body unchanged. Call `add_comment` once with:
    1. `${{ env.REFINE_MARKER }}`
    2. `${{ env.SAFE_OUTPUT_COMMENT_PREFIX }}`
    3. `I have some questions about this issue. Please reply in one comment and I'll process your answers.`
-   4. Every clarification question immediately below it, each answerable in a sentence.
+   4. Every set-aside question, gathered from all work units, immediately below it, each answerable in a sentence.
 
    Write the questions in **plain business language, not technical jargon**. The person reading
    them is a domain expert, not an engineer.
 
-    **The story is complete.** Call `update_issue` with the replacement body and `add_comment`
+    **The story is complete.** You answered every exploration question yourself and none remain
+    for the author. Call `update_issue` with the replacement body and `add_comment`
     with `${{ env.REFINE_MARKER }}`, then `${{ env.SAFE_OUTPUT_COMMENT_PREFIX }}`,
     then exactly one of these messages, based only on the `labels` array in the supplied issue
     context:
@@ -310,7 +350,8 @@ flowchart TD
     refPick{"Issue eligible?"} -->|yes| refReserve
     refPick -.->|no| refIdle
     refReserve("Reserve<br/>bot-working") --> refFacts
-    refFacts("Facts<br/>Issue and comments to disk") --> refStory
+    refFacts("Facts<br/>Issue and comments to disk") --> refExplore
+    refExplore("Explore<br/>ob-plan-explore per work unit,<br/>self-answer, bounded") --> refStory
     refStory("Story<br/>/plan-story, grounded in the code") -->|✓| refProse
     refStory -.->|✗| refFail
     refProse("Prose<br/>@humanizer over the final text") -->|✓| refOutcome
@@ -330,7 +371,7 @@ flowchart TD
     classDef success fill:#e8f8ec,stroke:#18883c,stroke-width:2px,color:#145a32
 
     class refStart start
-    class refReserve,refFacts,refStory,refProse action
+    class refReserve,refFacts,refExplore,refStory,refProse action
     class refPick,refOutcome decision
     class refIdle idle
     class refFail failure

package/loops/workflows/work-router.yml

@@ -69,8 +69,7 @@ on:
     - cron: "17 1 * * 1"
     - cron: "43 3 * * *"
     - cron: "0 6 * * *"
-    - cron: "*/15 * * * *"
-    - cron: "0 */2 * * *"
+    - cron: "*/30 * * * *"
     - cron: "29 7 * * *"
 
   workflow_dispatch:
@@ -90,7 +89,6 @@ on:
           - audit-close
           - cleanup-artifacts
           - reconcile-bot-pr-runs
-          - stale-recovery
           - validate
       issue-number:
         description: "Issue number (required for refine / implement / direct)"
@@ -229,9 +227,41 @@ jobs:
       BOT_APP_ID: ${{ secrets.BOT_APP_ID }}
       BOT_PRIVATE_KEY: ${{ secrets.BOT_PRIVATE_KEY }}
 
-  call-implement:
+  # Checks whether an open bot PR already exists for the issue. If it does, implement is
+  # skipped — the merge-gate will handle fixing the existing PR. This prevents duplicate
+  # PRs when retries are triggered after a merge-gate failure.
+  check-implement-pr:
     needs: [classify, authorize]
     if: needs.classify.outputs.route == 'implement' && needs.authorize.outputs.trusted == 'true'
+    runs-on: RunnerLandingZone
+    timeout-minutes: 3
+    permissions:
+      contents: read
+      pull-requests: read
+    outputs:
+      has-open-pr: ${{ steps.check.outputs.has-open-pr }}
+    steps:
+      - name: Check for existing open bot PR
+        id: check
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          ISSUE_NUMBER: ${{ needs.classify.outputs.issue-number }}
+        run: |
+          set -euo pipefail
+          existing=$(gh pr list --repo "$REPO" --state open \
+            --search "is:pr linked:issue $ISSUE_NUMBER" \
+            --json number,author --jq '[.[] | select(.author.login | test("[bot]$"))] | length')
+          if [ "$existing" -gt 0 ]; then
+            echo "has-open-pr=true" >> "$GITHUB_OUTPUT"
+            echo "::notice::Issue #$ISSUE_NUMBER already has an open bot PR. Skipping implement to prevent duplicates."
+          else
+            echo "has-open-pr=false" >> "$GITHUB_OUTPUT"
+          fi
+
+  call-implement:
+    needs: [classify, authorize, check-implement-pr]
+    if: needs.classify.outputs.route == 'implement' && needs.authorize.outputs.trusted == 'true' && needs.check-implement-pr.outputs.has-open-pr != 'true'
     uses: ./.github/workflows/agent-implement.lock.yml
     concurrency:
       group: write-pipeline-${{ needs.classify.outputs.issue-number }}
@@ -505,29 +535,6 @@ jobs:
           token: ${{ github.token }}
           artifact-retention-days: ${{ vars.ARTIFACT_RETENTION_DAYS }}
 
-  stale-recovery:
-    needs: classify
-    if: needs.classify.outputs.route == 'stale-recovery'
-    runs-on: RunnerLandingZone
-    timeout-minutes: 15
-    concurrency:
-      group: stale-recovery
-      cancel-in-progress: false
-    permissions:
-      contents: read
-      issues: write
-      pull-requests: read
-      actions: write
-    steps:
-      - name: Checkout workflow actions
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - uses: ./.github/actions/stale-recovery
-        with:
-          token: ${{ github.token }}
-          stale-threshold-hours: ${{ vars.STALE_THRESHOLD_HOURS }}
-
   validate:
     needs: classify
     if: needs.classify.outputs.route == 'validate'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plainconceptsplatform/workflows",
-  "version": "0.4.28",
+  "version": "0.4.32",
   "description": "Install and update Platform GitHub agentic workflows.",
   "keywords": [
     "github-actions",
@@ -40,4 +40,4 @@
     "typescript": "^5.8.0",
     "vitest": "^3.0.0"
   }
-}
+}