@guanlin4924/devflow-pi 0.1.39 → 0.1.47

package/plugins/devflow-core/skills/workflow-orchestrator/templates/feature-development.yaml

@@ -45,6 +45,7 @@ governance:
       - slice-independence-check
       - contract-coverage-check
       - change-impact-check
+      - cross-track-consistency-check
     acceptance-test-design:
       - requirement-graph-check
       - contract-coverage-check
@@ -123,6 +124,10 @@ parallel_windows:
     checkpoint: CP-2
     execution_policy:
       mode: parallel_when_supported
+      scheduler:
+        one_agent_per_step: true
+        max_concurrency: 2
+        track_order: declared
       serial_fallback_order:
         - backend-tech-spec
         - api-call-guide
@@ -218,6 +223,30 @@ checkpoints:
       - approve
       - needs_fix
     skip_policy: never
+    resume_behavior: "user confirms, then continue with wireframe-proposal"
+  CP-WIREFRAME:
+    name: Low-fidelity wireframe confirmation
+    gate_after: wireframe-review
+    producing_step: wireframe-review
+    required_outputs:
+      - ".planning/features/{feature}/canonical.json"
+      - ".planning/features/{feature}/canonical.meta.json"
+      - ".planning/features/{feature}/wireframes/preview.md"
+      - ".planning/features/{feature}/wireframes/flow.svg"
+    required_meta_output: ".planning/features/{feature}/canonical.meta.json"
+    required_meta_fields:
+      - prototype_fingerprint
+      - source_document_fingerprint
+      - state_revision
+    summary_fields:
+      - prototype_fingerprint
+      - source_document_fingerprint
+      - state_revision
+    prompt: "确认页面、元素、动作和平台范围；阻塞问题必须已回答，并允许进入 API 契约设计。"
+    confirm_options:
+      - approve
+      - needs_fix
+    skip_policy: never
     resume_behavior: "user confirms, then continue with api-contract"
   CP-API:
     name: API contract confirmation
@@ -482,6 +511,84 @@ steps:
         traceability_status: { type: string, required: true }
     checkpoint: CP-1
 
+  - id: wireframe-proposal
+    order: 11
+    label: Wireframe proposal
+    skill: wireframe-proposal
+    engine_evidence_gate: enforced
+    depends_on:
+      - requirement-baseline
+    inputs:
+      - ".planning/requirements/baseline.md"
+      - ".planning/requirements/{feature}/traceability.json"
+      - ".planning/features/{feature}/questions.yaml"
+    outputs:
+      - path: ".planning/features/{feature}/proposal.yaml"
+        type: wireframe-proposal
+        required: true
+      - path: ".planning/features/{feature}/questions.yaml"
+        type: wireframe-questions
+        required: false
+
+  - id: wireframe-validate
+    order: 12
+    label: Validate wireframe proposal
+    skill: wireframe-validate
+    engine_evidence_gate: enforced
+    depends_on:
+      - wireframe-proposal
+    inputs:
+      - ".planning/features/{feature}/proposal.yaml"
+      - ".planning/features/{feature}/questions.yaml"
+      - ".planning/requirements/{feature}/traceability.json"
+    outputs:
+      - path: ".planning/features/{feature}/canonical.json"
+        type: wireframe-canonical
+        required: true
+    meta_output:
+      path: ".planning/features/{feature}/wireframe-validation.meta.json"
+      fields:
+        verdict: { type: string, required: true }
+        canonical_fingerprint: { type: string, required: false }
+        unresolved_question_count: { type: integer, required: true }
+
+  - id: wireframe-render
+    order: 13
+    label: Render wireframe previews
+    skill: wireframe-render
+    engine_evidence_gate: enforced
+    depends_on:
+      - wireframe-validate
+    inputs:
+      - ".planning/features/{feature}/canonical.json"
+      - ".planning/features/{feature}/canonical.meta.json"
+    outputs:
+      - path: ".planning/features/{feature}/wireframes/preview.md"
+        type: wireframe-preview
+        required: true
+      - path: ".planning/features/{feature}/wireframes/flow.svg"
+        type: wireframe-flow
+        required: true
+
+  - id: wireframe-review
+    order: 14
+    label: Wireframe review
+    skill: wireframe-review
+    engine_evidence_gate: enforced
+    depends_on:
+      - wireframe-render
+    inputs:
+      - ".planning/features/{feature}/canonical.json"
+      - ".planning/features/{feature}/canonical.meta.json"
+      - ".planning/features/{feature}/questions.yaml"
+      - ".planning/features/{feature}/wireframes/preview.md"
+      - ".planning/features/{feature}/wireframes/flow.svg"
+    outputs:
+      - path: ".planning/features/{feature}/approval.json"
+        type: wireframe-approval
+        required: false
+    checkpoint: CP-WIREFRAME
+
   - id: api-contract
     order: 15
     label: API contract
@@ -873,7 +980,7 @@ steps:
     skill: workflow-generate-mainflow-cases
     engine_evidence_gate: enforced
     depends_on:
-      - code-index-refresh
+      - execute
     inputs:
       - ".planning/STATE.md"
       - ".planning/navigation/INDEX.md"
@@ -887,6 +994,9 @@ steps:
       - ".planning/features/{feature}/PROGRESS.md"
       - ".planning/requirements/{feature}/tests.json"
     outputs:
+      - path: ".planning/generated-cases/{feature}/codebase-discovery.json"
+        type: mainflow-codebase-discovery
+        required: true
       - path: ".planning/generated-cases/{feature}/source-map.md"
         type: mainflow-source-map
         required: true

package/plugins/devflow-implementation/agents/implementation-worker.md

@@ -18,6 +18,12 @@ autoloadSkills:
 
 Implement only the assigned plan slice. Do not re-plan the feature, compare alternatives, or explore unrelated modules. Read only the approved files, their immediate dependencies, and the focused tests needed for this slice. Preserve unrelated work and report deviations instead of silently expanding scope.
 
+Before any protected source access, read the project's required code-index evidence
+files in the exact order listed by INDEX_GATE (typically `.planning/code-index/INDEX.md`
+followed by the ordered files named by the gate). Do not attempt `grep`, `rg`, or source
+reads first: each subagent has its own evidence session and cannot inherit the parent's
+observations. If the gate lists different files, follow that list exactly.
+
 If the execution contract is missing, ambiguous, or contradicted by the code, stop before editing and return `STATUS: escalate` with the conflicting evidence. Run the smallest focused validation once; report failures rather than repeatedly trying speculative fixes.
 
 For a task whose frozen `test-bindings.json` marks `test_mode: tdd_required`, use the Core tool in this exact order: `devflow_tdd_evidence(action="prepare")` before changing declared production paths; create/change the test and record `red`; implement; record `green`; then record `regression`. Do not mark the task done if any phase is missing or fails. The tool may write only its own Core-owned TDD evidence record; this exception does not authorize edits to any other Devflow control-plane file.

package/plugins/devflow-intel/skills/workflow-code-index/scripts/code_index.py

@@ -5,6 +5,7 @@ import json
 import os
 import shutil
 import sqlite3
+import subprocess
 import sys
 import tempfile
 import uuid
@@ -14,8 +15,6 @@ from typing import Dict, Iterable, List, Set, Tuple
 
 import fcntl
 
-sys.dont_write_bytecode = True
-
 SCRIPT_DIR = Path(__file__).resolve().parent
 if str(SCRIPT_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPT_DIR))
@@ -58,13 +57,14 @@ def _index_lock(output: Path, exclusive: bool):
             fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
 
 
-def _publish_snapshot(staging: Path, output: Path, counts: Dict[str, int]) -> None:
+def _publish_snapshot(staging: Path, output: Path, counts: Dict[str, int], workspace_state: Dict[str, object]) -> None:
     generation = str(uuid.uuid4())
     snapshot = {
         "schemaVersion": 1,
         "generation": generation,
         "generatedAt": datetime.now(timezone.utc).isoformat(),
         "counts": counts,
+        "workspace": workspace_state,
         "artifacts": [*INDEX_FILES.values(), "index.sqlite", *MARKDOWN_FILES],
     }
     snapshot_path = staging / SNAPSHOT_FILE
@@ -72,8 +72,6 @@ def _publish_snapshot(staging: Path, output: Path, counts: Dict[str, int]) -> No
     with snapshot_path.open("rb") as handle:
         os.fsync(handle.fileno())
 
-    # Readers in this module hold the shared lock. SNAPSHOT.json is published
-    # last and is therefore the commit marker for external consumers.
     for name in snapshot["artifacts"]:
         os.replace(staging / name, output / name)
     os.replace(snapshot_path, output / SNAPSHOT_FILE)
@@ -84,6 +82,53 @@ def _publish_snapshot(staging: Path, output: Path, counts: Dict[str, int]) -> No
         os.close(directory_fd)
 
 
+def _workspace_state(root: Path, files: List[dict], changed: Set[str]) -> Dict[str, object]:
+    indexed_paths = sorted(record["path"] for record in files)
+    source_manifest_hash = _hash_lines(f"{record['path']}\0{record['content_hash']}" for record in files)
+    return {
+        "repositoryRevision": _git_output(root, ["rev-parse", "HEAD"]),
+        "contentManifestHash": source_manifest_hash,
+        "indexedPathsHash": _hash_lines(indexed_paths),
+        "dirtyPathsAtBuild": sorted(changed),
+    }
+
+
+def _worktree_signature(root: Path) -> str:
+    try:
+        proc = subprocess.run(
+            ["git", "status", "--porcelain=v1", "--untracked-files=all"],
+            cwd=str(root),
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+    except (OSError, FileNotFoundError):
+        return ""
+    if proc.returncode != 0:
+        return ""
+    kept = []
+    for line in proc.stdout.splitlines():
+        path = line[3:].strip() if len(line) > 3 else ""
+        if path.startswith(".planning/code-index/"):
+            continue
+        kept.append(line)
+    return "\n".join(kept)
+
+
+def _git_output(root: Path, args: List[str]) -> str:
+    try:
+        proc = subprocess.run(["git", *args], cwd=str(root), text=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, check=False)
+    except (OSError, FileNotFoundError):
+        return ""
+    return proc.stdout.strip() if proc.returncode == 0 else ""
+
+
+def _hash_lines(values) -> str:
+    digest = uuid.uuid5(uuid.NAMESPACE_URL, "\n".join(values))
+    return f"uuid5:{digest}"
+
+
 def main(argv=None) -> int:
     parser = argparse.ArgumentParser(description="Build and validate a generic code intelligence index.")
     sub = parser.add_subparsers(dest="command", required=True)
@@ -201,6 +246,7 @@ def command_scan(args) -> int:
                     "relations": len(relations),
                     "diagnostics": len(diagnostics),
                 },
+                _workspace_state(root, files, changed),
             )
         finally:
             shutil.rmtree(staging, ignore_errors=True)
@@ -212,38 +258,6 @@ def command_scan(args) -> int:
 
 def command_validate(args) -> int:
     output = Path(args.index).resolve()
-    with _index_lock(output, exclusive=False):
-        files, symbols, relations, diagnostics = _load_tuple(output)
-        errors = validate_index(files, symbols, relations, diagnostics)
-    if errors:
-        for error in errors:
-            print(error)
-        return 1
-    print("Code index schema validation passed.")
-    return 0
-
-
-def command_audit(args) -> int:
-    root = Path(args.root).resolve()
-    output = Path(args.index).resolve()
-    with _index_lock(output, exclusive=True):
-        files, symbols, relations, diagnostics = _load_tuple(output)
-        findings = []
-        findings.extend(audit_stale(root, files))
-        findings.extend(audit_relations(symbols, relations))
-        skill_root = Path(args.skill_root)
-        if skill_root.exists():
-            findings.extend(audit_project_binding([skill_root / "workflow-code-index", skill_root / "code-index-query"]))
-        write_audit(output, findings)
-    if findings:
-        for finding in findings[:200]:
-            location = f" {finding.get('path', '')}:{finding.get('line', '')}".rstrip(":")
-            print(f"{finding.get('severity', 'warning')}: {finding.get('kind', 'unknown')}: {finding.get('message', '')}{location}")
-        return 1
-    print("Code index audit passed.")
-    return 0
-
-
 def command_query(args) -> int:
     output = Path(args.index).resolve()
     with _index_lock(output, exclusive=False):
@@ -251,6 +265,11 @@ def command_query(args) -> int:
         if not index.exists():
             print(f"Missing index: {index}", file=sys.stderr)
             return 1
+        snapshot = _load_snapshot(output)
+        files = read_jsonl(output / INDEX_FILES["files"])
+        if not _query_is_fresh(output.parent.parent, snapshot, files):
+            print("Stale code index: refresh required before query.", file=sys.stderr)
+            return 1
         conn = sqlite3.connect(str(index))
         conn.row_factory = sqlite3.Row
         try:
@@ -283,6 +302,57 @@ def command_query(args) -> int:
     return 0
 
 
+def _load_snapshot(output: Path) -> Dict[str, object]:
+    path = output / SNAPSHOT_FILE
+    if not path.exists():
+        return {}
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _query_is_fresh(root: Path, snapshot: Dict[str, object], files: List[dict]) -> bool:
+    workspace = snapshot.get("workspace") if isinstance(snapshot, dict) else None
+    if not isinstance(workspace, dict):
+        return False
+    if workspace.get("repositoryRevision") and workspace.get("repositoryRevision") != _git_output(root, ["rev-parse", "HEAD"]):
+        return False
+    indexed_manifest = _hash_lines(f"{record['path']}\0{record['content_hash']}" for record in files)
+    if workspace.get("contentManifestHash") != indexed_manifest:
+        return False
+    return True
+
+
+
+def command_audit(args) -> int:
+    root = Path(args.root).resolve()
+    output = Path(args.index).resolve()
+    with _index_lock(output, exclusive=True):
+        files, symbols, relations, diagnostics = _load_tuple(output)
+        findings = []
+        findings.extend(audit_stale(root, files))
+        findings.extend(audit_relations(symbols, relations))
+        skill_root = Path(args.skill_root)
+        if skill_root.exists():
+            findings.extend(audit_project_binding([skill_root / "workflow-code-index", skill_root / "code-index-query"]))
+        write_audit(output, findings)
+    if findings:
+        for finding in findings[:200]:
+            location = f" {finding.get('path', '')}:{finding.get('line', '')}".rstrip(":")
+            print(f"{finding.get('severity', 'warning')}: {finding.get('kind', 'unknown')}: {finding.get('message', '')}{location}")
+        return 1
+    print("Code index audit passed.")
+    return 0
+
+
+def _load_snapshot(output: Path) -> Dict[str, object]:
+    path = output / SNAPSHOT_FILE
+    if not path.exists():
+        return {}
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+
+
+
 def _load_tuple(output: Path):
     return (
         read_jsonl(output / INDEX_FILES["files"]),

package/plugins/devflow-intel/skills/workflow-code-index/scripts/core/scanner.py

@@ -6,6 +6,7 @@ from typing import Iterable, List, Sequence
 
 DEFAULT_EXCLUDES = {
     ".git",
+    ".planning",
     "node_modules",
     "vendor",
     "dist",
@@ -59,7 +60,7 @@ TEXT_EXTENSIONS = {
 def scan_files(root: Path, excludes: Iterable[str] = (), max_bytes: int = 1_500_000) -> List[Path]:
     root = root.resolve()
     excluded = DEFAULT_EXCLUDES | set(excludes)
-    paths = _scan_with_rg(root, excluded) or _scan_with_walk(root, excluded)
+    paths = _scan_with_git(root, excluded) or _scan_with_rg(root, excluded) or _scan_with_walk(root, excluded)
     result: List[Path] = []
     for path in sorted(paths):
         if not path.is_file():
@@ -77,6 +78,24 @@ def scan_files(root: Path, excludes: Iterable[str] = (), max_bytes: int = 1_500_
     return result
 
 
+def _scan_with_git(root: Path, excluded: Sequence[str]) -> List[Path]:
+    try:
+        proc = subprocess.run(
+            ["git", "ls-files", "--cached", "--others", "--exclude-standard"],
+            cwd=str(root),
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+    except (OSError, FileNotFoundError):
+        return []
+    if proc.returncode != 0:
+        return []
+    return [root / line.strip() for line in proc.stdout.splitlines() if line.strip()]
+
+
+
 def _scan_with_rg(root: Path, excluded: Sequence[str]) -> List[Path]:
     ignore_args = []
     for name in excluded:

package/plugins/devflow-quality/skills/workflow-acceptance-test-design/SKILL.md

@@ -12,7 +12,7 @@ description: "Use after integration verification and before change planning to d
 本步骤的图谱写入受 ExecutionContract v2 约束：`devflow_requirement_graph(action="propose", kind="test_case")` 与 `devflow_api_test_matrix(action="import")` 仅在 active contract 的 step 为 `acceptance-test-design` 时放行。步骤开始且无 active contract 时：
 
 1. 先调用 `devflow_contract(action="status")` 检查当前会话是否有 active contract；
-2. 未激活时调用 `devflow_contract(action="activate", feature="<feature>", step="acceptance-test-design")` 合成并激活（planning / waiting-user / awaiting-approval 阶段均可，Core 校验 STATE 与图谱 revision 后由用户确认）；
+2. 未激活时调用 `devflow_contract(action="activate", feature="<feature>", step="acceptance-test-design")` 合成并激活（planning / waiting-user / awaiting-approval，或 Runtime 已触发当前步骤的 executing 回合均可；Core 校验 STATE 当前 feature/step 与图谱 revision 后由用户确认）；
 3. 会话中断后 contract 由 runtime 在 `session_start` 时从 `.planning/contracts/{feature}/EC-*.json` 自动恢复；恢复时校验 state/graph revision，推进后自动失效，需重新合成。
 
 ## 输入

package/src/constants.ts

@@ -1,5 +1,5 @@
 export const PRODUCT_NAME = "Devflow Pi";
-export const PRODUCT_VERSION = "0.1.39";
+export const PRODUCT_VERSION = "0.1.47";
 export const PROJECT_SCHEMA_VERSION = 1;
 export const OMP_RUNTIME_VERSION = "17.2.7";
 

package/src/runtime.ts

@@ -1,10 +1,12 @@
 import { mkdir, readFile, rm } from "node:fs/promises";
+import { homedir } from "node:os";
 import path from "node:path";
 
 import { OMP_RUNTIME_VERSION, PRODUCT_NAME, PRODUCT_VERSION } from "./constants.ts";
 import { createPlatformExtension } from "./platform-extension.ts";
 import { devflowAgentDir, devflowHome, pluginRoots, projectSessionDir, sharedOmpAgentDir } from "./paths.ts";
 import type { ProjectContext } from "./project-context.ts";
+import { injectOmpExtensionCliRoots } from "@oh-my-pi/pi-coding-agent/discovery/omp-extension-roots";
 
 export interface RuntimeOptions {
   initialPrompt?: string;
@@ -36,12 +38,18 @@ const MANAGED_SETTINGS: Record<string, unknown> = {
   "skills.enableAgentsProject": false,
   // The interactive session is the high-capability Planner. Low-cost agents
   // are dispatched only through explicit Devflow steps, one at a time by
-  // default, so background work cannot silently widen a user's request.
+  // default, so background work cannot silently widen a user's request.  The
+  // parallel workflow window is explicitly capped at two workers, matching
+  // its two declared tracks; serial workflows are unaffected.
   // Keep ordinary interactive turns on the user's DEFAULT role. In particular,
   // do not inherit SLOW just because a thinking model is configured.
   "defaultThinkingLevel": "low",
+  // Parallel Devflow orchestration relies on OMP's AsyncJobManager and
+  // subagent lifecycle channel. Keep this explicit instead of inheriting the
+  // SDK default so a global OMP config cannot silently disable it.
+  "async.enabled": true,
   "task.batch": false,
-  "task.maxConcurrency": 1,
+  "task.maxConcurrency": 2,
   "task.maxRecursionDepth": 1,
   "task.enableLsp": true,
   // Keep cheap workers bounded by role prompts. OMP's loop guards remain
@@ -96,6 +104,12 @@ export async function createEmbeddedRuntime(project: ProjectContext, options: Ru
   utils.logger.setTransports({ file: path.join(productHome, "logs") });
   const omp = await import("@oh-my-pi/pi-coding-agent");
   const roots = pluginRoots();
+  // Task workers perform a fresh agent discovery after session creation. The
+  // SDK's temporary extension-root scope does not cover that later lookup,
+  // so register Devflow package roots as durable CLI roots for this process.
+  // Without this, packaged agents such as implementation-worker appear during
+  // startup but fail with Unknown agent when a parallel task is dispatched.
+  injectOmpExtensionCliRoots(roots, homedir(), project.root, { mode: "explicit-only", replace: true });
   // Reuse credentials and model discovery from the user's OMP agent, but not
   // its config.yml: a global modelRoles block would override choices made in
   // Devflow's own Roles screen after every restart.
@@ -128,28 +142,37 @@ export async function createEmbeddedRuntime(project: ProjectContext, options: Ru
   } else {
     sessionManager = omp.SessionManager.create(project.root, sessionDir);
   }
-  const runtime = await omp.createAgentSession({
-    cwd: project.root,
-    agentDir: productAgentDir,
-    settings,
-    authStorage,
-    modelRegistry,
-    sessionManager,
-    additionalExtensionPaths: roots,
-    disableExtensionDiscovery: true,
-    extensions: [
-      createPlatformExtension({
-        sessionRoot: sessionDir,
-        ompSessionRoot: path.join(sharedAgentDir, "sessions"),
-        projectId: project.manifest.projectId,
-        getConfiguredRole: role => settings.getModelRole(role),
-      }),
-    ],
-    hasUI: options.hasUI ?? true,
-    enableMCP: options.enableMCP ?? false,
-    enableLsp: options.enableLsp ?? true,
-    appendSystemPrompt: TOOL_CALL_SAFETY_PROMPT,
-  });
+  const previousCliResumeSignal = process.env.DEVFLOW_CLI_SESSION_RESUME;
+  if (options.resume) process.env.DEVFLOW_CLI_SESSION_RESUME = "1";
+  else delete process.env.DEVFLOW_CLI_SESSION_RESUME;
+  let runtime;
+  try {
+    runtime = await omp.createAgentSession({
+      cwd: project.root,
+      agentDir: productAgentDir,
+      settings,
+      authStorage,
+      modelRegistry,
+      sessionManager,
+      additionalExtensionPaths: roots,
+      disableExtensionDiscovery: true,
+      extensions: [
+        createPlatformExtension({
+          sessionRoot: sessionDir,
+          ompSessionRoot: path.join(sharedAgentDir, "sessions"),
+          projectId: project.manifest.projectId,
+          getConfiguredRole: role => settings.getModelRole(role),
+        }),
+      ],
+      hasUI: options.hasUI ?? true,
+      enableMCP: options.enableMCP ?? false,
+      enableLsp: options.enableLsp ?? true,
+      appendSystemPrompt: TOOL_CALL_SAFETY_PROMPT,
+    });
+  } finally {
+    if (previousCliResumeSignal === undefined) delete process.env.DEVFLOW_CLI_SESSION_RESUME;
+    else process.env.DEVFLOW_CLI_SESSION_RESUME = previousCliResumeSignal;
+  }
   return { omp, runtime, sessionDir };
 }
 
@@ -250,6 +273,15 @@ export async function runInteractiveRuntime(project: ProjectContext, options: Ru
       void consumeControlledRollover();
     }, delay);
   };
+  // A control-plane request may be created by an extension input handler that
+  // marks the message handled, so it is not guaranteed to pass through the
+  // normal submitInteractiveInput return path. Keep a small runtime-owned
+  // poller alive for the lifetime of the interactive loop; it only touches the
+  // filesystem when a durable rollover request exists.
+  const rolloverPoller = setInterval(() => {
+    void consumeControlledRollover();
+  }, 500);
+  rolloverPoller.unref?.();
   // A prepared handoff is a durable runtime request, not something that
   // should wait for the user to type another command after a restart.
   await consumeControlledRollover();
@@ -257,5 +289,10 @@ export async function runInteractiveRuntime(project: ProjectContext, options: Ru
     const input = await mode.getUserInput();
     await omp.submitInteractiveInput(mode, runtime.session, input);
     await consumeControlledRollover();
+    // The submitted turn may create a durable rollover request after the
+    // immediate check above returns. Poll once while the UI is waiting for the
+    // next user input so a successful step does not require a dummy message to
+    // trigger the fresh-session handoff.
+    scheduleControlledRolloverRetry();
   }
 }