codebyplan 1.13.12 → 1.13.14

package/dist/cli.js

@@ -14,7 +14,7 @@ var VERSION, PACKAGE_NAME;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    VERSION = "1.13.12";
+    VERSION = "1.13.14";
     PACKAGE_NAME = "codebyplan";
   }
 });
@@ -1281,7 +1281,11 @@ var init_template_walker = __esm({
       "hooks/validate-structure-lengths.sh",
       "hooks/validate-structure-smoke.sh",
       "hooks/validate-context-usage.sh",
-      "hooks/validate-git-commit.sh"
+      "hooks/validate-git-commit.sh",
+      // Advisory GATE-6 sibling-identity nudge — fires ONLY in the templates source
+      // repo (detects packages/codebyplan-package/templates/). A no-op for consumers,
+      // so it ships neither in hooks.json nor as a copied file.
+      "hooks/cbp-canonical-templates-nudge.sh"
     ]);
   }
 });
@@ -5897,6 +5901,310 @@ var init_resolve_worktree2 = __esm({
   }
 });
 
+// src/cli/create-org.ts
+var create_org_exports = {};
+__export(create_org_exports, {
+  runCreateOrg: () => runCreateOrg
+});
+import { stdin as stdin3, stdout as stdout4 } from "node:process";
+import { createInterface as createInterface3 } from "node:readline/promises";
+function deriveSlug(name) {
+  const trimmed = name.trim();
+  if (trimmed === "") return "";
+  const slug = trimmed.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "org";
+}
+async function runCreateOrg() {
+  const rl = createInterface3({ input: stdin3, output: stdout4 });
+  console.log("\n  CodeByPlan \u2014 Create Organization\n");
+  try {
+    const rawName = (await rl.question("  Organization name: ")).trim();
+    if (!rawName) {
+      console.error("\n  Error: Organization name cannot be empty.\n");
+      process.exitCode = 1;
+      return;
+    }
+    const slug = deriveSlug(rawName);
+    if (slug) {
+      console.log(`  Slug preview: ${slug}
+`);
+    }
+    let response;
+    try {
+      response = await apiPost("/organizations", {
+        name: rawName
+      });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        console.error(`
+  Error: ${err.message} (HTTP ${err.status})
+`);
+      } else {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`
+  Error: ${msg}
+`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const org = response.data;
+    console.log("\n  Organization created successfully.\n");
+    console.log(`    id:   ${org.id}`);
+    console.log(`    name: ${org.name}`);
+    console.log(`    slug: ${org.slug}
+`);
+  } finally {
+    rl.close();
+  }
+}
+var init_create_org = __esm({
+  "src/cli/create-org.ts"() {
+    "use strict";
+    init_api();
+  }
+});
+
+// src/cli/create-project.ts
+var create_project_exports = {};
+__export(create_project_exports, {
+  runCreateProject: () => runCreateProject
+});
+import { stdin as stdin4, stdout as stdout5 } from "node:process";
+import { createInterface as createInterface4 } from "node:readline/promises";
+function deriveSlug2(name) {
+  const trimmed = name.trim();
+  if (trimmed === "") return "";
+  const slug = trimmed.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "project";
+}
+async function runCreateProject() {
+  const rl = createInterface4({ input: stdin4, output: stdout5 });
+  console.log("\n  CodeByPlan \u2014 Create Project\n");
+  try {
+    const orgIdFlag = (() => {
+      const idx = process.argv.indexOf("--org-id");
+      return idx !== -1 ? process.argv[idx + 1] ?? "" : "";
+    })();
+    let organizationId;
+    if (orgIdFlag) {
+      organizationId = orgIdFlag.trim();
+    } else {
+      let orgs = null;
+      try {
+        const resp = await apiGet("/organizations");
+        if (resp.data && resp.data.length > 0) {
+          orgs = resp.data;
+        }
+      } catch {
+      }
+      if (orgs && orgs.length > 0) {
+        console.log("  Available organizations:\n");
+        orgs.forEach((org, i) => {
+          console.log(`    ${i + 1}. ${org.name} (${org.slug})  [${org.id}]`);
+        });
+        console.log("");
+        const rawChoice = (await rl.question(
+          `  Select organization (1\u2013${orgs.length}) or paste an org ID: `
+        )).trim();
+        const choiceNum = parseInt(rawChoice, 10);
+        if (!isNaN(choiceNum) && choiceNum >= 1 && choiceNum <= orgs.length) {
+          organizationId = orgs[choiceNum - 1].id;
+        } else if (rawChoice) {
+          organizationId = rawChoice;
+        } else {
+          console.error("\n  Error: Organization selection cannot be empty.\n");
+          process.exitCode = 1;
+          return;
+        }
+      } else {
+        const rawOrgId = (await rl.question("  Organization ID: ")).trim();
+        if (!rawOrgId) {
+          console.error("\n  Error: Organization ID cannot be empty.\n");
+          process.exitCode = 1;
+          return;
+        }
+        organizationId = rawOrgId;
+      }
+    }
+    const rawName = (await rl.question("  Project name: ")).trim();
+    if (!rawName) {
+      console.error("\n  Error: Project name cannot be empty.\n");
+      process.exitCode = 1;
+      return;
+    }
+    const slug = deriveSlug2(rawName);
+    if (slug) {
+      console.log(`  Slug preview: ${slug}
+`);
+    }
+    let response;
+    try {
+      response = await apiPost("/projects", {
+        organization_id: organizationId,
+        name: rawName
+      });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        console.error(`
+  Error: ${err.message} (HTTP ${err.status})
+`);
+      } else {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`
+  Error: ${msg}
+`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const project = response.data;
+    console.log("\n  Project created successfully.\n");
+    console.log(`    id:   ${project.id}`);
+    console.log(`    name: ${project.name}`);
+    console.log(`    slug: ${project.slug}
+`);
+  } finally {
+    rl.close();
+  }
+}
+var init_create_project = __esm({
+  "src/cli/create-project.ts"() {
+    "use strict";
+    init_api();
+  }
+});
+
+// src/cli/create-repo.ts
+var create_repo_exports = {};
+__export(create_repo_exports, {
+  runCreateRepo: () => runCreateRepo
+});
+import { stdin as stdin5, stdout as stdout6 } from "node:process";
+import { createInterface as createInterface5 } from "node:readline/promises";
+async function runCreateRepo() {
+  const rl = createInterface5({ input: stdin5, output: stdout6 });
+  console.log("\n  CodeByPlan \u2014 Create Repository\n");
+  try {
+    const projectIdFlag = (() => {
+      const idx = process.argv.indexOf("--project-id");
+      return idx !== -1 ? process.argv[idx + 1] ?? "" : "";
+    })();
+    let projectId;
+    if (projectIdFlag) {
+      const trimmedFlag = projectIdFlag.trim();
+      if (!UUID_RE.test(trimmedFlag)) {
+        console.error("\n  Error: Project ID must be a valid UUID.\n");
+        process.exitCode = 1;
+        return;
+      }
+      projectId = trimmedFlag;
+    } else {
+      let projects = null;
+      try {
+        const resp = await apiGet("/projects");
+        if (resp.data && resp.data.length > 0) {
+          projects = resp.data;
+        }
+      } catch {
+      }
+      if (projects && projects.length > 0) {
+        console.log("  Available projects:\n");
+        projects.forEach((proj, i) => {
+          console.log(
+            `    ${i + 1}. ${proj.name} (${proj.slug})  [${proj.id}]`
+          );
+        });
+        console.log("");
+        const rawChoice = (await rl.question(
+          `  Select project (1\u2013${projects.length}) or paste a project ID: `
+        )).trim();
+        const choiceNum = parseInt(rawChoice, 10);
+        if (!isNaN(choiceNum) && choiceNum >= 1 && choiceNum <= projects.length) {
+          projectId = projects[choiceNum - 1].id;
+        } else if (rawChoice) {
+          if (!UUID_RE.test(rawChoice)) {
+            console.error("\n  Error: Project ID must be a valid UUID.\n");
+            process.exitCode = 1;
+            return;
+          }
+          projectId = rawChoice;
+        } else {
+          console.error("\n  Error: Project selection cannot be empty.\n");
+          process.exitCode = 1;
+          return;
+        }
+      } else {
+        const rawProjectId = (await rl.question("  Project ID: ")).trim();
+        if (!rawProjectId) {
+          console.error("\n  Error: Project ID cannot be empty.\n");
+          process.exitCode = 1;
+          return;
+        }
+        if (!UUID_RE.test(rawProjectId)) {
+          console.error("\n  Error: Project ID must be a valid UUID.\n");
+          process.exitCode = 1;
+          return;
+        }
+        projectId = rawProjectId;
+      }
+    }
+    const rawName = (await rl.question("  Repository name: ")).trim();
+    if (!rawName) {
+      console.error("\n  Error: Repository name cannot be empty.\n");
+      process.exitCode = 1;
+      return;
+    }
+    const rawPath = (await rl.question("  Local path (optional, press Enter to skip): ")).trim();
+    const rawBranch = (await rl.question(
+      "  Default git branch (optional, press Enter for 'main'): "
+    )).trim();
+    const git_branch = rawBranch || "main";
+    let response;
+    try {
+      response = await apiPost("/repos", {
+        project_id: projectId,
+        name: rawName,
+        ...rawPath ? { path: rawPath } : {},
+        git_branch
+      });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        console.error(`
+  Error: ${err.message} (HTTP ${err.status})
+`);
+      } else {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`
+  Error: ${msg}
+`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const repo = response.data;
+    console.log("\n  Repository created successfully.\n");
+    console.log(`    id:         ${repo.id}`);
+    console.log(`    name:       ${repo.name}`);
+    console.log(`    git_branch: ${repo.git_branch ?? git_branch}`);
+    console.log(
+      `
+  Tip: run \`codebyplan setup\` from the repo directory to link it.
+`
+    );
+  } finally {
+    rl.close();
+  }
+}
+var UUID_RE;
+var init_create_repo = __esm({
+  "src/cli/create-repo.ts"() {
+    "use strict";
+    init_api();
+    UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  }
+});
+
 // src/cli/version-status.ts
 var version_status_exports = {};
 __export(version_status_exports, {
@@ -7875,6 +8183,21 @@ void (async () => {
     await runResolveWorktree2();
     process.exit(0);
   }
+  if (arg === "create-org") {
+    const { runCreateOrg: runCreateOrg2 } = await Promise.resolve().then(() => (init_create_org(), create_org_exports));
+    await runCreateOrg2();
+    process.exit(0);
+  }
+  if (arg === "create-project") {
+    const { runCreateProject: runCreateProject2 } = await Promise.resolve().then(() => (init_create_project(), create_project_exports));
+    await runCreateProject2();
+    process.exit(0);
+  }
+  if (arg === "create-repo") {
+    const { runCreateRepo: runCreateRepo2 } = await Promise.resolve().then(() => (init_create_repo(), create_repo_exports));
+    await runCreateRepo2();
+    process.exit(0);
+  }
   if (arg === "version-status") {
     const { runVersionStatus: runVersionStatus2 } = await Promise.resolve().then(() => (init_version_status(), version_status_exports));
     await runVersionStatus2();
@@ -7970,6 +8293,9 @@ void (async () => {
     codebyplan logout                Clear cached OAuth tokens
     codebyplan whoami                Show currently authenticated identity
     codebyplan upgrade-auth          Migrate legacy x-api-key MCP config to OAuth
+    codebyplan create-org            Create a new organization (interactive prompt)
+    codebyplan create-project        Create a new project within an organization (interactive prompt)
+    codebyplan create-repo           Create a new repository within a project (interactive prompt)
     codebyplan config                Sync repo config from DB to .codebyplan/ files
     codebyplan ports                 Verify port allocations against local package.json scripts
     codebyplan tech-stack            Detect and sync tech stack dependencies

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebyplan",
-  "version": "1.13.12",
+  "version": "1.13.14",
   "description": "CLI for CodeByPlan — AI-powered development planning and tracking",
   "type": "module",
   "bin": {
@@ -61,6 +61,6 @@
     "prettier": "^3.8.1",
     "typescript": "^5",
     "typescript-eslint": "^8.20.0",
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.2"
   }
 }

package/templates/hooks/hooks.json

@@ -18,10 +18,6 @@
           {
             "type": "command",
             "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/cbp-maestro-yaml-validate.sh"
-          },
-          {
-            "type": "command",
-            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/cbp-canonical-templates-nudge.sh"
           }
         ]
       },

package/templates/rules/task-routing-recommendation.md

@@ -0,0 +1,51 @@
+---
+name: task-routing-recommendation
+scope: repo-only:codebyplan
+description: Routing guide — when to use /cbp-task-* vs /cbp-standalone-task-*
+---
+
+# Task Routing Recommendation
+
+## Two-Family Command Surface
+
+CodeByPlan has two families of task commands since CHK-141:
+
+| Family | Commands | When to use |
+|--------|----------|-------------|
+| Checkpoint-bound | `/cbp-task-create`, `/cbp-task-start {chk}-{task}`, `/cbp-task-check`, `/cbp-task-testing`, `/cbp-task-complete` | Work that belongs to a CHK-NNN checkpoint |
+| Standalone | `/cbp-standalone-task-create`, `/cbp-standalone-task-start {task}`, `/cbp-standalone-task-check`, `/cbp-standalone-task-testing`, `/cbp-standalone-task-complete` | Independent work not tied to any checkpoint |
+
+## Round Commands (Both Families)
+
+All `/cbp-round-*` commands work for both task families. The correct family is detected from the active task:
+- Checkpoint-bound task in progress → round commands use checkpoint MCP tools
+- Standalone task in progress → round commands use standalone MCP tools
+
+## Identifier Format
+
+| Context | Correct format | Example |
+|---------|----------------|---------|
+| Checkpoint-bound task | `{chk}-{task}` | `141-3` = CHK-141 TASK-3 |
+| Standalone task | `{task}` (bare number) | `45` = standalone TASK-45 |
+| Round of checkpoint task | `{chk}-{task}-{round}` | `141-3-1` |
+| Round of standalone task | `{task}-{round}` | `45-2` |
+
+## Bare-Number Rejection Rule
+
+Since CHK-141, `/cbp-task-*` commands reject bare-number arguments. If you type `/cbp-task-start 45`, you will see:
+
+```
+task-start: bare number `45` is no longer valid here.
+Use /cbp-standalone-task-start 45 instead — bare numbers no longer route to standalone tasks.
+```
+
+## Close-Out Routing
+
+After task completion, routes use single-directive form (never A/B/C menus):
+
+**Checkpoint-bound task complete:**
+- More tasks in checkpoint → auto-triggers next task (same context)
+- Last task in checkpoint → `Next: /clear, then /cbp-checkpoint-check`
+
+**Standalone task complete:**
+- Always → `Next: /cbp-session-end` (or `/cbp-standalone-task-create` for new work)

package/templates/settings.project.base.json

@@ -58,6 +58,8 @@
       "mcp__codebyplan__create_launch",
       "mcp__codebyplan__update_launch",
       "mcp__codebyplan__delete_launch",
+      "mcp__codebyplan__create_organization",
+      "mcp__codebyplan__create_project",
       "mcp__codebyplan__create_repo",
       "mcp__codebyplan__delete_session_log",
       "mcp__codebyplan__delete_worktree",
@@ -67,6 +69,12 @@
       "mcp__codebyplan__release_assignment",
       "Bash(codebyplan setup:*)",
       "Bash(npx codebyplan setup:*)",
+      "Bash(codebyplan create-org:*)",
+      "Bash(npx codebyplan create-org:*)",
+      "Bash(codebyplan create-project:*)",
+      "Bash(npx codebyplan create-project:*)",
+      "Bash(codebyplan create-repo:*)",
+      "Bash(npx codebyplan create-repo:*)",
       "Bash(codebyplan login:*)",
       "Bash(npx codebyplan login:*)",
       "Bash(codebyplan logout:*)",

package/templates/skills/cbp-round-check/SKILL.md

@@ -7,6 +7,27 @@ effort: low
 
 <!-- Re-read this file before executing. Do not rely on memory. -->
 
+## Kind Detection
+
+Inspect the resolved identifier from argument parsing to determine the task kind:
+
+| Identifier shape | KIND |
+|-----------------|------|
+| `{task}-{round}` (2-segment, e.g. `45-2`) | `standalone` |
+| `{chk}-{task}-{round}` (3-segment, e.g. `141-3-1`) | `checkpoint` |
+| _(empty / free-text)_ | Check `get_current_standalone_task` first; if found → `standalone`. Else → `checkpoint` via `get_current_task`. |
+
+Set `KIND` for the rest of this skill. MCP tool names vary by KIND:
+
+| Operation | `checkpoint` KIND | `standalone` KIND |
+|-----------|------------------|-------------------|
+| Get task | `get_current_task(repo_id)` | `get_current_standalone_task(repo_id)` |
+| Get rounds | `get_rounds(task_id)` | `get_standalone_rounds(standalone_task_id)` |
+| Add round | `add_round(task_id, ...)` | `add_standalone_round(standalone_task_id, ...)` |
+| Update round | `update_round(round_id, ...)` | `update_standalone_round(standalone_round_id, ...)` |
+| Complete round | `complete_round(round_id, duration_minutes?)` | `complete_standalone_round(standalone_round_id, duration_minutes?, caller_worktree_id)` ⚠️ `caller_worktree_id` is REQUIRED for standalone |
+| Update task | `update_task(task_id, ...)` | `update_standalone_task(standalone_task_id, ...)` |
+
 # Round Check Command
 
 Run automated checks independently with mandatory execution. Updates round QA. Hard fails if mandatory checks (build/lint/types) fail.
@@ -15,7 +36,10 @@ Run automated checks independently with mandatory execution. Updates round QA. H
 
 ### Step 1: Get Current Round
 
-Use MCP `get_current_task` to find active task, then `get_rounds` to find the in-progress round.
+Use Kind Detection above to set KIND. Then:
+
+- **checkpoint KIND**: MCP `get_current_task(repo_id)` to find active task, then `get_rounds(task_id)` to find the in-progress round.
+- **standalone KIND**: MCP `get_current_standalone_task(repo_id)` to find active task, then `get_standalone_rounds(standalone_task_id)` to find the in-progress round.
 
 ### Step 2: Determine Project Root
 
@@ -59,7 +83,7 @@ Scan all captured output for:
 
 ### Step 6: Save QA Results
 
-Update round QA via MCP `update_round(round_id, qa: ...)`:
+Update round QA via MCP `update_round(round_id, qa: ...)` (checkpoint KIND) or `update_standalone_round(standalone_round_id, qa: ...)` (standalone KIND):
 
 ```json
 {
@@ -99,6 +123,6 @@ If soft failures only: `Run /cbp-round-start to trigger auto-fix, or fix manuall
 
 ## Integration
 
-- **Reads**: MCP `get_current_task`, `get_rounds`
-- **Writes**: MCP `update_round` (qa field)
+- **Reads**: MCP `get_current_task` / `get_current_standalone_task`, `get_rounds` / `get_standalone_rounds` (per KIND)
+- **Writes**: MCP `update_round` / `update_standalone_round` (qa field) — per KIND
 - **Standalone**: Can be run independently at any time

package/templates/skills/cbp-round-end/SKILL.md

@@ -5,6 +5,27 @@ description: Summary wrap-up after testing phase completes
 effort: high
 ---
 
+## Kind Detection
+
+Inspect the resolved identifier from argument parsing to determine the task kind:
+
+| Identifier shape | KIND |
+|-----------------|------|
+| `{task}-{round}` (2-segment, e.g. `45-2`) | `standalone` |
+| `{chk}-{task}-{round}` (3-segment, e.g. `141-3-1`) | `checkpoint` |
+| _(empty / free-text)_ | Check `get_current_standalone_task` first; if found → `standalone`. Else → `checkpoint` via `get_current_task`. |
+
+Set `KIND` for the rest of this skill. MCP tool names vary by KIND:
+
+| Operation | `checkpoint` KIND | `standalone` KIND |
+|-----------|------------------|-------------------|
+| Get task | `get_current_task(repo_id)` | `get_current_standalone_task(repo_id)` |
+| Get rounds | `get_rounds(task_id)` | `get_standalone_rounds(standalone_task_id)` |
+| Add round | `add_round(task_id, ...)` | `add_standalone_round(standalone_task_id, ...)` |
+| Update round | `update_round(round_id, ...)` | `update_standalone_round(standalone_round_id, ...)` |
+| Complete round | `complete_round(round_id, duration_minutes?)` | `complete_standalone_round(standalone_round_id, duration_minutes?, caller_worktree_id)` ⚠️ `caller_worktree_id` is REQUIRED for standalone |
+| Update task | `update_task(task_id, ...)` | `update_standalone_task(standalone_task_id, ...)` |
+
 # Round End Command
 
 Summary phase — presents what was done, then runs code quality review to catch bugs and logic errors that automated checks miss.
@@ -21,14 +42,16 @@ See `reference/inline-fallback.md` for full trigger table, procedure, and covera
 
 ## Identifier Notation
 
-This skill operates on the **active** task/round resolved via MCP `get_current_task` / `get_rounds` and does not accept a positional identifier argument. Canonical chk-task-round notation — used in prose, error messages, and cross-references — follows `.claude/rules/notation-consistency.md` "CHK / TASK / ROUND Identifier Notation": `108-1` (CHK-108 TASK-1), `45` (standalone TASK-45), `108-1-2` (round 2 of CHK-108 TASK-1), `45-2` (round 2 of standalone TASK-45).
+This skill operates on the **active** task/round resolved via MCP and does not accept a positional identifier argument. Canonical chk-task-round notation — used in prose, error messages, and cross-references — follows `.claude/rules/notation-consistency.md` "CHK / TASK / ROUND Identifier Notation": `108-1` (CHK-108 TASK-1), `45` (standalone TASK-45), `108-1-2` (round 2 of CHK-108 TASK-1), `45-2` (round 2 of standalone TASK-45).
 
 ## Instructions
 
 ### Step 1: Get Current Task and Round
 
-Use MCP `get_current_task` with repo_id (pass `checkpoint_id` if known to avoid disambiguation) to find the active task.
-Use MCP `get_rounds` for the task to find the in-progress round.
+Use Kind Detection above to set KIND. Then:
+
+- **checkpoint KIND**: MCP `get_current_task(repo_id)` (pass `checkpoint_id` if known) to find the active task. MCP `get_rounds(task_id)` to find the in-progress round.
+- **standalone KIND**: MCP `get_current_standalone_task(repo_id)` to find the active task. MCP `get_standalone_rounds(standalone_task_id)` to find the in-progress round.
 
 Load round context with all outputs (executor_output, testing_qa_output, reviewer_output).
 
@@ -70,11 +93,11 @@ Merge with previous rounds (supersede items for re-modified files, preserve veri
 
 ### Step 4: Update Task Files and QA
 
-Update via MCP:
+Update via MCP using KIND-appropriate tools:
 
-- `update_task(task_id, files_changed: [...])` — merge with existing
-- `update_round(round_id, files_changed: [...], qa: {items: [auto_qa items + default_checklist items]})` — round-specific
-- `update_task(task_id, qa: {items: [auto_qa items + default_checklist items]})` — aggregated
+- `update_task(task_id, files_changed: [...])` / `update_standalone_task(standalone_task_id, files_changed: [...])` — merge with existing
+- `update_round(round_id, files_changed: [...], qa: {items: [auto_qa items + default_checklist items]})` / `update_standalone_round(standalone_round_id, ...)` — round-specific
+- `update_task(task_id, qa: {items: [auto_qa items + default_checklist items]})` / `update_standalone_task(standalone_task_id, qa: {items: [auto_qa items + default_checklist items]})` — aggregated
 
 ### Step 5: Present Summary
 
@@ -137,8 +160,8 @@ Example tables and the `inline` option gating spec: see `reference/findings-pres
 - Auto-accept ALL findings into `improve_round_findings[]` regardless of severity (the user opted into the loop).
 - Skip the polish-spiral stop-gate (auto-loop has its own cap-exhausted termination).
 - Skip the user findings-decision prompt.
-- Save findings via `update_round` exactly as in manual mode.
-- Auto-trigger `/cbp-round-update` immediately. round-update Step 6 will decide whether to spawn another round or exit clean (see cbp-round-update SKILL.md Step 6).
+- Save findings via `update_round` / `update_standalone_round` per KIND exactly as in manual mode.
+- Auto-trigger `/cbp-round-update` immediately. round-update Step 4 will decide whether to spawn another round or exit clean (see cbp-round-update SKILL.md Step 4).
 
 **Else (manual mode — flag absent or false):**
 
@@ -146,7 +169,7 @@ Run the existing flow:
 
 1. After round 2+, surface the polish-spiral stop-gate per `polish-spiral-stop-gate.md` (defer-to-followups vs continue).
 2. Surface the findings-decision AskUserQuestion (with optional `inline` per the gating rules in `reference/findings-presentation.md`).
-3. Save accepted/rejected findings to round context via MCP `update_round`:
+3. Save accepted/rejected findings to round context via MCP `update_round` / `update_standalone_round` per KIND:
    ```json
    {
      "context": {
@@ -167,7 +190,7 @@ Run the existing flow:
 ## Integration
 
 - **Triggered by**: `/cbp-round-execute` (auto, after all waves + testing complete)
-- **Reads**: MCP `get_current_task`, `get_rounds`, round context
-- **Writes**: MCP `update_round`, `update_task` (files_changed, qa, findings)
+- **Reads**: MCP `get_current_task` / `get_current_standalone_task`, `get_rounds` / `get_standalone_rounds` (per KIND), round context
+- **Writes**: MCP `update_round` / `update_standalone_round`, `update_task` / `update_standalone_task` (files_changed, qa, findings) — per KIND
 - **Spawns**: `cbp-improve-round` (code quality review)
 - **Triggers**: `/cbp-round-update` (auto, after findings handled)