@sienklogic/plan-build-run 2.57.0 → 2.59.0

package/plugins/cursor-pbr/skills/setup/SKILL.md

@@ -57,6 +57,8 @@ Stop. Do not proceed further.
 
 ## Step 2: Model Selection
 
+Note: These profiles control agent models, not the orchestrator. The orchestrator uses your Claude Code session model. For cost optimization, consider running your session on Sonnet -- agents with `inherit` will follow. See `references/model-profiles.md` for details.
+
 Use AskUserQuestion:
   question: "Which model profile should agents use?"
   header: "Models"
@@ -133,7 +135,69 @@ This project uses [Plan-Build-Run](https://github.com/SienkLogic/plan-build-run)
 
 ---
 
-## Step 5: Write Updated Config
+## Step 5: Platform Settings
+
+Manage Claude Code platform settings that PBR recommends for optimal token usage.
+
+**Read `.planning/config.json`** (already loaded in Step 1). Check for a `platform_settings` block:
+- If absent, treat it as `{}` (no managed settings).
+
+**Check for existing `.claude/settings.json`**:
+- If it exists, read its contents. Parse as JSON (or `{}` if empty/missing).
+- If it does not exist, start from `{}`.
+
+**Compute the merge**:
+- Start with the existing `.claude/settings.json` content.
+- Apply each key from `platform_settings` in config.json on top.
+- If `platform_settings` is absent or empty, skip the write entirely.
+
+**Report drift** (compare before/after):
+- List keys being ADDED (were absent in .claude/settings.json)
+- List keys being CHANGED (differ from existing .claude/settings.json value)
+- List keys that MATCH (already correct — no change needed)
+
+Display the report:
+
+```
+Platform Settings:
+  Keys added:   includeGitInstructions → false
+  Keys matched: (none)
+  Keys changed: (none)
+
+Writing .claude/settings.json...
+```
+
+If all keys already match, display:
+
+```
+Platform Settings: .claude/settings.json is already in sync — no changes needed.
+```
+
+**Conflict detection**: If an existing `.claude/settings.json` has a key from `platform_settings` set to the OPPOSITE value (e.g., `"includeGitInstructions": true` when PBR wants `false`), display a WARNING before overwriting:
+
+```
+WARNING: .claude/settings.json has includeGitInstructions: true
+         PBR recommends false (removes redundant built-in git instructions).
+         Overwriting with PBR recommended value.
+```
+
+**Write the merged settings.json**:
+- Write to `.claude/settings.json` in the project root (alongside `.planning/`).
+- Ensure the directory `.claude/` exists (create it if needed with Bash `mkdir -p .claude`).
+- Write with 2-space indentation. Include a `$schema` key at the top:
+  ```json
+  {
+    "$schema": "https://json.schemastore.org/claude-code-settings.json",
+    "includeGitInstructions": false
+  }
+  ```
+  (Merge in any pre-existing keys from .claude/settings.json that are NOT managed by PBR — pass them through unchanged at the bottom of the object.)
+
+**Drift detection note**: On subsequent /pbr:setup runs, if `.claude/settings.json` has drifted from `platform_settings` (e.g., user manually changed it), this step will detect and re-apply the PBR values with a drift warning. This is by design — platform_settings in config.json is the source of truth.
+
+---
+
+## Step 6: Write Updated Config
 
 **CRITICAL: Write `.planning/config.json` NOW with all changes from Steps 2-3. Do NOT skip this step.**
 
@@ -141,13 +205,14 @@ Write the updated config.json to disk with all applied changes.
 
 ---
 
-## Step 6: Verification
+## Step 7: Verification
 
 Run a quick check:
 1. Verify `.planning/config.json` is valid JSON (read it back)
 2. Display updated settings summary
 
 Display:
+
 ```
 ╔══════════════════════════════════════════════════════════════╗
 ║  PLAN-BUILD-RUN ► RECONFIGURE COMPLETE ✓                     ║
@@ -157,6 +222,7 @@ Updated:
 - Model profile: {new profile}
 - Features changed: {list or "none"}
 - CLAUDE.md: {updated/skipped}
+- Platform settings: {".claude/settings.json updated" or "already in sync" or "no managed settings"}
 
 Run /pbr:status to see current project state.
 ```

package/plugins/pbr/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pbr",
-  "version": "2.57.0",
+  "version": "2.59.0",
   "description": "Plan-Build-Run — Structured development workflow for Claude Code. Solves context rot through disciplined subagent delegation, structured planning, atomic execution, and goal-backward verification.",
   "author": {
     "name": "SienkLogic",

package/plugins/pbr/agents/audit.md

@@ -1,7 +1,6 @@
 ---
 name: audit
 description: "Analyzes Claude Code session logs for PBR workflow compliance, hook firing, state file hygiene, and user experience quality."
-model: sonnet
 memory: none
 tools:
   - Read

package/plugins/pbr/agents/codebase-mapper.md

@@ -1,7 +1,6 @@
 ---
 name: codebase-mapper
 description: "Explores existing codebases and writes structured analysis documents. Four focus areas: tech, arch, quality, concerns."
-model: sonnet
 memory: none
 tools:
   - Read

package/plugins/pbr/agents/debugger.md

@@ -1,7 +1,6 @@
 ---
 name: debugger
 description: "Systematic debugging using scientific method. Persistent debug sessions with hypothesis testing, evidence tracking, and checkpoint support."
-model: sonnet
 memory: project
 tools:
   - Read

package/plugins/pbr/agents/dev-sync.md

@@ -1,7 +1,6 @@
 ---
 name: dev-sync
 description: "Syncs PBR plugin changes to cursor-pbr and copilot-pbr derivatives with format adjustments."
-model: sonnet
 memory: none
 tools:
   - Read

package/plugins/pbr/agents/executor.md

@@ -1,7 +1,6 @@
 ---
 name: executor
 description: "Executes plan tasks with atomic commits, deviation handling, checkpoint protocols, TDD support, and self-verification."
-model: sonnet
 memory: project
 tools:
   - Read

package/plugins/pbr/agents/general.md

@@ -1,7 +1,6 @@
 ---
 name: general
 description: "Lightweight Plan-Build-Run-aware agent for ad-hoc tasks that don't fit specialized roles."
-model: sonnet
 memory: none
 tools:
   - Read

package/plugins/pbr/agents/integration-checker.md

@@ -1,7 +1,6 @@
 ---
 name: integration-checker
 description: "Cross-phase integration and E2E flow verification. Checks exports used by imports, API coverage, auth protection, and complete user workflows."
-model: sonnet
 memory: none
 tools:
   - Read

package/plugins/pbr/agents/plan-checker.md

@@ -1,7 +1,6 @@
 ---
 name: plan-checker
 description: "Verifies plans will achieve phase goals before execution. Goal-backward analysis of plan quality across 10 dimensions."
-model: sonnet
 memory: none
 tools:
   - Read

package/plugins/pbr/agents/planner.md

@@ -1,7 +1,6 @@
 ---
 name: planner
 description: "Creates executable phase plans with task breakdown, dependency analysis, wave assignment, and goal-backward verification. Also creates roadmaps."
-model: sonnet
 memory: project
 tools:
   - Read

package/plugins/pbr/agents/researcher.md

@@ -1,7 +1,6 @@
 ---
 name: researcher
 description: "Unified research agent for project domains, phase implementation approaches, and synthesis. Follows source-hierarchy methodology with confidence levels."
-model: sonnet
 memory: user
 tools:
   - Read

package/plugins/pbr/agents/synthesizer.md

@@ -1,7 +1,6 @@
 ---
 name: synthesizer
 description: "Fast synthesis of multiple research outputs into coherent recommendations. Resolves contradictions between sources."
-model: sonnet
 memory: none
 tools:
   - Read

package/plugins/pbr/agents/verifier.md

@@ -1,7 +1,6 @@
 ---
 name: verifier
 description: "Goal-backward phase verification. Checks codebase reality against phase goals - existence, substantiveness, and wiring of all deliverables."
-model: sonnet
 memory: none
 isolation: worktree
 tools:

package/plugins/pbr/commands/profile.md

@@ -0,0 +1,7 @@
+---
+name: profile
+description: "Switch the active model profile. Presets: quality, balanced, budget, adaptive. Supports custom profiles from config.json model_profiles."
+skill: profile
+---
+
+This command is provided by the `pbr:profile` skill.

package/plugins/pbr/hooks/hooks.json

@@ -18,6 +18,39 @@
         ]
       }
     ],
+    "InstructionsLoaded": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"var r=process.env.CLAUDE_PLUGIN_ROOT||'',m=r.match(/^\\/([a-zA-Z])\\/(.*)/);if(m)r=m[1]+String.fromCharCode(58)+String.fromCharCode(92)+m[2];require(require('path').resolve(r,'scripts','run-hook.js'))\" instructions-loaded.js",
+            "statusMessage": "Detecting instruction reload..."
+          }
+        ]
+      }
+    ],
+    "WorktreeCreate": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"var r=process.env.CLAUDE_PLUGIN_ROOT||'',m=r.match(/^\\/([a-zA-Z])\\/(.*)/);if(m)r=m[1]+String.fromCharCode(58)+String.fromCharCode(92)+m[2];require(require('path').resolve(r,'scripts','run-hook.js'))\" worktree-create.js",
+            "statusMessage": "Initializing worktree .planning/..."
+          }
+        ]
+      }
+    ],
+    "WorktreeRemove": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"var r=process.env.CLAUDE_PLUGIN_ROOT||'',m=r.match(/^\\/([a-zA-Z])\\/(.*)/);if(m)r=m[1]+String.fromCharCode(58)+String.fromCharCode(92)+m[2];require(require('path').resolve(r,'scripts','run-hook.js'))\" worktree-remove.js",
+            "statusMessage": "Cleaning up worktree state..."
+          }
+        ]
+      }
+    ],
     "PostToolUse": [
       {
         "matcher": "Write|Edit",

package/plugins/pbr/references/model-profiles.md

@@ -4,9 +4,29 @@ How Plan-Build-Run maps agents to models and how to configure model selection.
 
 ---
 
+## Session Model (Orchestrator)
+
+The orchestrator is your main Claude Code session -- it reads skills, manages state, and routes work to agents. Its model is whatever you selected in Claude Code (not controlled by PBR's `config.json`).
+
+**Cost impact:** The orchestrator accounts for roughly 40% of total session cost. Agents set to `inherit` (planner, executor, debugger, general in the `balanced` profile) also use this model. Switching your session from Opus to Sonnet reduces cost for both the orchestrator and all `inherit` agents.
+
+**Recommendations:**
+
+| Goal | Session Model | Config Adjustment |
+|------|---------------|-------------------|
+| Maximum quality | Opus | None needed -- `inherit` agents get Opus |
+| Balanced cost/quality | Sonnet | None needed -- `inherit` agents get Sonnet, which handles most tasks well |
+| Cheap orchestration, Opus agents | Sonnet | Set `planner: "opus"`, `executor: "opus"`, `debugger: "opus"` to override inherit |
+
+Sonnet 4.6 handles orchestration tasks (state reading, routing decisions, context assembly) effectively. Reserve Opus for agents doing complex reasoning, architecture, or novel code generation.
+
+---
+
 ## Agent-to-Model Mapping
 
-Each Plan-Build-Run agent has a default model specified in its agent definition frontmatter (`model:` field). These defaults are overridden by the `models` section of `config.json`.
+Each Plan-Build-Run agent's model is controlled by `config.json models.*`. When no config entry exists for an agent, the agent inherits the session model.
+
+The `model:` frontmatter field has been removed from PBR agent definitions — `config.json` is now the sole source of truth for agent model assignment.
 
 ### Default Agent Models
 
@@ -22,8 +42,10 @@ Each Plan-Build-Run agent has a default model specified in its agent definition
 | `codebase-mapper` | `sonnet` | Codebase analysis requires thorough reasoning |
 | `synthesizer` | `haiku` | Synthesis is mechanical combination; speed over depth |
 | `general` | `inherit` | Lightweight utility; inherits session model |
+| `audit` | `inherit` | Session log analysis inherits session model |
+| `dev-sync` | `inherit` | Cross-plugin sync is mechanical; inherits session model |
 
-The `inherit` value means the agent uses whatever model the parent session is running (typically the user's configured Claude model).
+The `inherit` value means the agent uses whatever model the parent session is running (typically the user's configured Claude model). Defaults listed above are the effective values from the `balanced` profile in `config.json`.
 
 ---
 
@@ -88,6 +110,28 @@ Note: Claude Code 2.1.45+ supports Sonnet 4.6. Model values are abstract names
 
 ---
 
+## Custom Profiles
+
+The `model_profiles` key in `config.json` lets you define named profiles beyond the four built-in presets. Each profile is a partial map of agent names to model strings — omitted agents fall back to the active profile defaults.
+
+```json
+{
+  "model_profiles": {
+    "my-profile": {
+      "executor": "opus",
+      "planner": "opus",
+      "synthesizer": "sonnet"
+    }
+  }
+}
+```
+
+Activate a custom profile with `/pbr:config model-profile my-profile`. The profile merges with the `balanced` preset: any agent not listed in your custom profile uses its `balanced` default.
+
+Partial profiles are allowed — you can override just the agents you care about. This is useful for temporarily upgrading a single agent without specifying the rest.
+
+---
+
 ## Model Selection in Skill Orchestration
 
 Skills that spawn subagents use the `model` parameter in `Task()` calls. Some skills hardcode a lighter model for specific tasks:
@@ -96,4 +140,4 @@ Skills that spawn subagents use the `model` parameter in `Task()` calls. Some sk
 - **Build skill**: Spawns codebase mapper updates with `model: "haiku"` for incremental map refreshes
 - **Plan skill**: Uses the configured `planner` model for main planning work
 
-The `subagent_type` parameter automatically loads the agent definition, and the model from `config.json` takes precedence over the agent's default `model:` frontmatter field.
+The `subagent_type` parameter automatically loads the agent definition, and the model from `config.json` takes precedence over any agent-level model setting.

package/plugins/pbr/references/model-selection.md

@@ -14,7 +14,7 @@ Plan-Build-Run uses adaptive model selection to balance cost and capability.
 |-----------|-------|-----------|
 | simple | haiku | Fast, cheap — sufficient for mechanical changes |
 | medium | sonnet | Good balance for standard feature work |
-| complex | inherit | Uses session model — typically Opus for critical work |
+| complex | inherit | Uses session model — see `model-profiles.md` Session Model section for cost implications |
 
 ## Override Mechanisms
 

package/plugins/pbr/scripts/check-subagent-output.js

@@ -421,7 +421,7 @@ async function main() {
   }
 
   // Extract agent type from the Task completion data
-  const agentType = data.tool_input?.subagent_type || data.subagent_type || '';
+  const agentType = data.agent_type || data.tool_input?.subagent_type || data.subagent_type || '';
 
   // Only check known Plan-Build-Run agent types
   const outputSpec = AGENT_OUTPUTS[agentType];

package/plugins/pbr/scripts/config-schema.json

@@ -52,6 +52,24 @@
       },
       "additionalProperties": false
     },
+    "model_profiles": {
+      "type": "object",
+      "description": "User-defined custom model profiles. Each key is a profile name; value is an object mapping agent names to model strings (sonnet, opus, haiku, inherit). Partial profiles allowed — omitted agents fall back to the active profile defaults.",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "researcher": { "type": "string" },
+          "planner": { "type": "string" },
+          "executor": { "type": "string" },
+          "verifier": { "type": "string" },
+          "integration_checker": { "type": "string" },
+          "debugger": { "type": "string" },
+          "mapper": { "type": "string" },
+          "synthesizer": { "type": "string" }
+        },
+        "additionalProperties": false
+      }
+    },
     "parallelization": {
       "type": "object",
       "properties": {

package/plugins/pbr/scripts/hooks-schema.json

@@ -10,6 +10,7 @@
       "type": "object",
       "properties": {
         "SessionStart": { "$ref": "#/definitions/hookEntryList" },
+        "InstructionsLoaded": { "$ref": "#/definitions/hookEntryList" },
         "PreToolUse": { "$ref": "#/definitions/hookEntryList" },
         "PostToolUse": { "$ref": "#/definitions/hookEntryList" },
         "PostToolUseFailure": { "$ref": "#/definitions/hookEntryList" },
@@ -19,7 +20,9 @@
         "SubagentStop": { "$ref": "#/definitions/hookEntryList" },
         "TaskCompleted": { "$ref": "#/definitions/hookEntryList" },
         "ConfigChange": { "$ref": "#/definitions/hookEntryList" },
-        "SessionEnd": { "$ref": "#/definitions/hookEntryList" }
+        "SessionEnd": { "$ref": "#/definitions/hookEntryList" },
+        "WorktreeCreate": { "$ref": "#/definitions/hookEntryList" },
+        "WorktreeRemove": { "$ref": "#/definitions/hookEntryList" }
       },
       "additionalProperties": false
     }

package/plugins/pbr/scripts/instructions-loaded.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+/**
+ * InstructionsLoaded hook: Lightweight PBR state reminder after CLAUDE.md loads.
+ *
+ * Fires each time Claude Code loads CLAUDE.md or .claude/rules/*.md files.
+ * For PBR projects: injects a brief reminder that PBR workflow is active.
+ * Debounces mid-session re-fires using .session.json load timestamp.
+ *
+ * Non-blocking — always exits 0.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { logHook } = require('./hook-logger');
+
+function readStdin() {
+  try {
+    const input = fs.readFileSync(0, 'utf8').trim();
+    if (input) return JSON.parse(input);
+  } catch (_e) { /* empty or non-JSON stdin */ }
+  return {};
+}
+
+function main() {
+  const data = readStdin();
+  const cwd = process.env.PBR_PROJECT_ROOT || process.cwd();
+  const planningDir = path.join(cwd, '.planning');
+
+  // Only relevant for PBR projects
+  if (!fs.existsSync(planningDir)) {
+    process.exit(0);
+  }
+
+  // Debounce: only emit additionalContext on first fire per session.
+  // .session.json is written by progress-tracker.js at SessionStart.
+  // If it exists with a sessionStart timestamp, this is a mid-session reload.
+  let isMidSession = false;
+  try {
+    const sessionFile = path.join(planningDir, '.session.json');
+    if (fs.existsSync(sessionFile)) {
+      const session = JSON.parse(fs.readFileSync(sessionFile, 'utf8'));
+      if (session.sessionStart) {
+        isMidSession = true;
+      }
+    }
+  } catch (_e) { /* non-fatal */ }
+
+  logHook('instructions-loaded', 'InstructionsLoaded', isMidSession ? 'mid-session-reload' : 'initial-load', {
+    instructions_file: data.instructions_file || null
+  });
+
+  // Mid-session: note that instructions reloaded (CLAUDE.md may have changed)
+  if (isMidSession) {
+    process.stdout.write(JSON.stringify({
+      additionalContext: '[Plan-Build-Run] Project CLAUDE.md was reloaded mid-session. If PBR workflow rules changed, current skill invocation may be affected. Check .planning/STATE.md for current position.'
+    }));
+    process.exit(0);
+  }
+
+  // Initial load: no additionalContext needed — progress-tracker.js already
+  // injected full state at SessionStart. Avoid double-injection.
+  process.exit(0);
+}
+
+if (require.main === module || process.argv[1] === __filename) { main(); }
+module.exports = { main };

package/plugins/pbr/scripts/lib/gates/helpers.js

@@ -15,6 +15,13 @@ const path = require('path');
  * @returns {string|null}
  */
 function readActiveSkill(planningDir) {
+  // Check .session.json first (consistent with check-subagent-output.js and log-subagent.js)
+  try {
+    const { sessionLoad } = require('../../pbr-tools');
+    const session = sessionLoad(planningDir);
+    if (session && session.activeSkill) return session.activeSkill;
+  } catch (_e) { /* pbr-tools unavailable */ }
+  // Fall back to legacy .active-skill file
   try {
     return fs.readFileSync(path.join(planningDir, '.active-skill'), 'utf8').trim();
   } catch (_e) {

package/plugins/pbr/scripts/lib/init.js

@@ -17,8 +17,9 @@ const { phaseInfo, planIndex } = require('./phase');
  *
  * @param {string} phaseNum - Phase number
  * @param {string} [planningDir] - Path to .planning directory
+ * @param {string} [overrideModel] - Optional model override from --model CLI flag (sonnet|opus|haiku|inherit)
  */
-function initExecutePhase(phaseNum, planningDir) {
+function initExecutePhase(phaseNum, planningDir, overrideModel) {
   const dir = planningDir || path.join(process.env.PBR_PROJECT_ROOT || process.cwd(), '.planning');
   const state = stateLoad(dir);
   if (!state.exists) return { error: "No .planning/ directory found" };
@@ -36,8 +37,8 @@ function initExecutePhase(phaseNum, planningDir) {
     gitState = { branch, clean: status === "" };
   } catch (_e) { /* not a git repo */ }
   return {
-    executor_model: models.executor || "sonnet",
-    verifier_model: models.verifier || "sonnet",
+    executor_model: overrideModel || models.executor || "sonnet",
+    verifier_model: overrideModel || models.verifier || "sonnet",
     config: { depth: depthProfile.depth, mode: config.mode || "interactive", parallelization: config.parallelization || { enabled: false }, planning: config.planning || {}, gates: config.gates || {}, features: config.features || {} },
     phase: { num: phaseNum, dir: phase.phase, name: phase.name, goal: phase.goal, has_context: phase.has_context, status: phase.filesystem_status, plan_count: phase.plan_count, completed: phase.completed },
     plans: (plans.plans || []).map(p => ({ file: p.file, plan_id: p.plan_id, wave: p.wave, autonomous: p.autonomous, has_summary: p.has_summary, must_haves_count: p.must_haves_count, depends_on: p.depends_on })),
@@ -51,8 +52,9 @@ function initExecutePhase(phaseNum, planningDir) {
  *
  * @param {string} phaseNum - Phase number
  * @param {string} [planningDir] - Path to .planning directory
+ * @param {string} [overrideModel] - Optional model override from --model CLI flag (sonnet|opus|haiku|inherit)
  */
-function initPlanPhase(phaseNum, planningDir) {
+function initPlanPhase(phaseNum, planningDir, overrideModel) {
   const dir = planningDir || path.join(process.env.PBR_PROJECT_ROOT || process.cwd(), '.planning');
   const state = stateLoad(dir);
   if (!state.exists) return { error: "No .planning/ directory found" };
@@ -72,7 +74,7 @@ function initPlanPhase(phaseNum, planningDir) {
     if (rp) { phaseGoal = rp.goal; phaseDeps = rp.depends_on; }
   }
   return {
-    researcher_model: models.researcher || "sonnet", planner_model: models.planner || "sonnet", checker_model: models.planner || "sonnet",
+    researcher_model: overrideModel || models.researcher || "sonnet", planner_model: overrideModel || models.planner || "sonnet", checker_model: overrideModel || models.planner || "sonnet",
     config: { depth: depthProfile.depth, profile: depthProfile.profile, features: config.features || {}, planning: config.planning || {} },
     phase: { num: phaseNum, dir: phaseDirName, goal: phaseGoal, depends_on: phaseDeps },
     existing_artifacts: existingArtifacts,
@@ -109,8 +111,9 @@ function initQuick(description, planningDir) {
  *
  * @param {string} phaseNum - Phase number
  * @param {string} [planningDir] - Path to .planning directory
+ * @param {string} [overrideModel] - Optional model override from --model CLI flag (sonnet|opus|haiku|inherit)
  */
-function initVerifyWork(phaseNum, planningDir) {
+function initVerifyWork(phaseNum, planningDir, overrideModel) {
   const dir = planningDir || path.join(process.env.PBR_PROJECT_ROOT || process.cwd(), '.planning');
   const phase = phaseInfo(phaseNum, dir);
   if (phase.error) return { error: phase.error };
@@ -119,7 +122,7 @@ function initVerifyWork(phaseNum, planningDir) {
   let priorAttempts = 0;
   if (phase.verification) { priorAttempts = parseInt(phase.verification.attempt, 10) || 0; }
   return {
-    verifier_model: models.verifier || "sonnet",
+    verifier_model: overrideModel || models.verifier || "sonnet",
     phase: { num: phaseNum, dir: phase.phase, name: phase.name, goal: phase.goal, plan_count: phase.plan_count, completed: phase.completed },
     has_verification: !!phase.verification, prior_attempts: priorAttempts,
     prior_status: phase.verification ? (phase.verification.status || "unknown") : null,

package/plugins/pbr/scripts/pbr-tools.js

@@ -297,20 +297,20 @@ function milestoneStats(version) {
   return _milestoneStats(version, planningDir);
 }
 
-function initExecutePhase(phaseNum) {
-  return _initExecutePhase(phaseNum, planningDir);
+function initExecutePhase(phaseNum, overridePlanningDir, overrideModel) {
+  return _initExecutePhase(phaseNum, overridePlanningDir || planningDir, overrideModel);
 }
 
-function initPlanPhase(phaseNum) {
-  return _initPlanPhase(phaseNum, planningDir);
+function initPlanPhase(phaseNum, overridePlanningDir, overrideModel) {
+  return _initPlanPhase(phaseNum, overridePlanningDir || planningDir, overrideModel);
 }
 
 function initQuick(description) {
   return _initQuick(description, planningDir);
 }
 
-function initVerifyWork(phaseNum) {
-  return _initVerifyWork(phaseNum, planningDir);
+function initVerifyWork(phaseNum, overridePlanningDir, overrideModel) {
+  return _initVerifyWork(phaseNum, overridePlanningDir || planningDir, overrideModel);
 }
 
 function initResume() {