ai-dev-workflow 0.1.0__tar.gz → 0.2.0__tar.gz

{ai_dev_workflow-0.1.0 → ai_dev_workflow-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-dev-workflow
-Version: 0.1.0
+Version: 0.2.0
 Summary: Provider-neutral AI-assisted development workflow and CLI
 Author: vuthethienlong
 Project-URL: Homepage, https://github.com/vuthethienlong/ai-dev-workflow

{ai_dev_workflow-0.1.0 → ai_dev_workflow-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ai-dev-workflow"
-version = "0.1.0"
+version = "0.2.0"
 description = "Provider-neutral AI-assisted development workflow and CLI"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -37,6 +37,7 @@ py-modules = [
   "composite_work_item",
   "framework_update",
   "github_work_item_provider",
+  "instruction_adapter",
   "issue_publisher",
   "planning_context",
   "setup_context",

{ai_dev_workflow-0.1.0 → ai_dev_workflow-0.2.0}/tests/test_ai_workflow_cli.py

@@ -16,7 +16,7 @@ DISCOVERY={
 
 class Tests(unittest.TestCase):
     def test_package_version(self):
-        self.assertEqual(PACKAGE_VERSION, "0.1.0")
+        self.assertEqual(PACKAGE_VERSION, "0.2.0")
 
     def test_init_generates_explicit_mapping_and_agents(self):
         cfg=build_ado_config(DISCOVERY)

ai_dev_workflow-0.2.0/tests/test_instruction_adapter.py

@@ -0,0 +1,54 @@
+import tempfile, unittest
+from pathlib import Path
+
+from instruction_adapter import (
+    START, END, adapter_for_provider, ensure_provider_instruction_file, merge_managed_block
+)
+
+class Tests(unittest.TestCase):
+    def test_codex_uses_agents_directly(self):
+        adapter = adapter_for_provider("chatgpt-codex")
+        self.assertEqual(adapter["shared"], "AGENTS.md")
+        self.assertIsNone(adapter["provider_file"])
+
+    def test_claude_adapter_targets_claude_md(self):
+        adapter = adapter_for_provider("anthropic")
+        self.assertEqual(adapter["provider_file"], "CLAUDE.md")
+        self.assertEqual(adapter["merge_policy"], "preserve-existing")
+
+    def test_existing_user_rules_are_preserved(self):
+        original = "# Claude rules\n\nNever modify generated files.\n"
+        merged = merge_managed_block(original)
+        self.assertTrue(merged.startswith(original))
+        self.assertIn(START, merged)
+        self.assertIn("AGENTS.md", merged)
+        self.assertIn("CURRENT.md", merged)
+
+    def test_existing_managed_block_is_replaced_not_duplicated(self):
+        original = f"before\n{START}\nold\n{END}\nafter\n"
+        merged = merge_managed_block(original)
+        self.assertEqual(merged.count(START), 1)
+        self.assertEqual(merged.count(END), 1)
+        self.assertTrue(merged.startswith("before\n"))
+        self.assertTrue(merged.endswith("\nafter\n"))
+
+    def test_idempotent_file_update(self):
+        with tempfile.TemporaryDirectory() as td:
+            path = Path(td) / "CLAUDE.md"
+            path.write_text("# Mine\n", encoding="utf-8")
+            first = ensure_provider_instruction_file(td, "anthropic")
+            once = path.read_text(encoding="utf-8")
+            second = ensure_provider_instruction_file(td, "anthropic")
+            twice = path.read_text(encoding="utf-8")
+            self.assertTrue(first["changed"])
+            self.assertFalse(second["changed"])
+            self.assertEqual(once, twice)
+            self.assertIn("# Mine", twice)
+
+    def test_current_is_conditional_context(self):
+        merged = merge_managed_block("")
+        self.assertIn("active ai-dev-workflow task", merged)
+        self.assertIn("not required for unrelated sessions", merged)
+
+if __name__ == "__main__":
+    unittest.main()

{ai_dev_workflow-0.1.0 → ai_dev_workflow-0.2.0}/tests/test_setup_wizard.py

@@ -4,7 +4,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tools"))
 
 from github_work_item_provider import build_github_mapping, suggest_github_state, validate_github_mapping
 from setup_context import analyze_repository, setup_agent_context
-from setup_wizard import build_setup_plan, credential_requirements
+from setup_wizard import build_setup_plan, credential_requirements, interactive_setup_options, interactive_workspace_options, confirm_setup_plan
 
 class Tests(unittest.TestCase):
     def test_context_analysis_detects_project_signals(self):
@@ -61,4 +61,77 @@ class Tests(unittest.TestCase):
         self.assertEqual(suggest_github_state("Awaiting runtime verification"),"runtime-pending")
         self.assertIsNone(suggest_github_state("customer-impact"))
 
+
+    def test_full_wizard_collects_github_and_multi_repo(self):
+        class Args:
+            root="."
+            work_items=None
+            github_repository=None
+            github_auth=None
+            github_token_env="GH_TOKEN"
+            ado_organization=None
+            ado_project=None
+            ado_token_env="AZURE_DEVOPS_TOKEN"
+            ado_mcp_mode=None
+            ado_mcp_auth=None
+            ado_team=None
+            ai_provider=[]
+            role_provider=[]
+            worker=[]
+            environment=None
+            codespaces_mode=None
+            tdd=None
+            reviewer_mode=None
+            runtime_mode=None
+
+        answers=iter([
+            ".",                 # root
+            "1",                 # GitHub Issues
+            "owner/main",        # repository
+            "1",                 # gh-cli
+            "y",                 # multi-repo
+            "dragon-workspace",  # workspace name
+            "main",              # primary ref
+            "primary-game",      # primary purpose
+            "y",                 # add repo
+            "owner/shared",      # second repo
+            "shared-lib",        # purpose
+            "integration",       # ref
+            "1",                 # read
+            "AGENTS.md|docs/**", # context
+            "n",                 # no more repos
+            "owner/main",        # default repo
+            "n",                 # no Claude
+            "", "", "", "", "", "", # role defaults
+            "n",                 # no workers
+            "1",                 # env none
+            "",                  # TDD default yes
+            "1",                 # reviewer manual
+            "1",                 # runtime project-defined
+        ])
+        args=interactive_setup_options(Args(), input_fn=lambda _: next(answers), output_fn=lambda *_: None)
+        self.assertEqual(args.work_items,"github-issues")
+        self.assertEqual(args.github_repository,"owner/main")
+        self.assertEqual(args.workspace_config["workspace"]["name"],"dragon-workspace")
+        self.assertEqual(len(args.workspace_config["repositories"]),2)
+        self.assertEqual(args.workspace_config["repositories"][1]["repository"],"owner/shared")
+        self.assertEqual(args.workspace_config["planning"]["default_repository"],"owner/main")
+        self.assertTrue(args.tdd)
+
+    def test_workspace_can_be_skipped(self):
+        class Args:
+            github_repository="owner/repo"
+        answers=iter(["n"])
+        self.assertIsNone(interactive_workspace_options(Args(), input_fn=lambda _: next(answers), output_fn=lambda *_: None))
+
+    def test_review_can_cancel_apply(self):
+        plan={
+            "work_items":{"provider":"github-issues"},
+            "providers":{"codex":{}},
+            "workers":[],
+            "execution_environment":{"type":"none"},
+            "workflow":{"tdd":True,"reviewer":{"mode":"manual"},"runtime_verification":{"mode":"project-defined"}},
+        }
+        self.assertFalse(confirm_setup_plan(plan,input_fn=lambda _:"n",output_fn=lambda *_:None))
+
 if __name__=="__main__": unittest.main()

{ai_dev_workflow-0.1.0 → ai_dev_workflow-0.2.0}/tools/ai_dev_workflow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-dev-workflow
-Version: 0.1.0
+Version: 0.2.0
 Summary: Provider-neutral AI-assisted development workflow and CLI
 Author: vuthethienlong
 Project-URL: Homepage, https://github.com/vuthethienlong/ai-dev-workflow

{ai_dev_workflow-0.1.0 → ai_dev_workflow-0.2.0}/tools/ai_dev_workflow.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ tests/test_composite_work_item.py
 tests/test_connection_and_mcp.py
 tests/test_framework_update.py
 tests/test_general_init.py
+tests/test_instruction_adapter.py
 tests/test_issue_publisher.py
 tests/test_package_install.py
 tests/test_planning_context.py
@@ -23,6 +24,7 @@ tools/ai_workflow_cli.py
 tools/composite_work_item.py
 tools/framework_update.py
 tools/github_work_item_provider.py
+tools/instruction_adapter.py
 tools/issue_publisher.py
 tools/planning_context.py
 tools/setup_context.py

{ai_dev_workflow-0.1.0 → ai_dev_workflow-0.2.0}/tools/ai_dev_workflow.egg-info/top_level.txt

@@ -5,6 +5,7 @@ ai_workflow_cli
 composite_work_item
 framework_update
 github_work_item_provider
+instruction_adapter
 issue_publisher
 planning_context
 setup_context

{ai_dev_workflow-0.1.0 → ai_dev_workflow-0.2.0}/tools/ai_workflow_cli.py

@@ -13,7 +13,7 @@ except ImportError:
 
 from ado_provider import AzureDevOps, build_state_mapping, validate_mapping, validate_field_mapping
 from work_item_provider import REQUIRED_AGENT_ROLES, REQUIRED_CANONICAL_STATES
-from setup_wizard import build_setup_plan, discover_provider, interactive_mapping, interactive_ado_field_mapping, render_user_steps, apply_github_status_bootstrap
+from setup_wizard import build_setup_plan, discover_provider, interactive_mapping, interactive_ado_field_mapping, render_user_steps, apply_github_status_bootstrap, interactive_setup_options, confirm_setup_plan
 from github_work_item_provider import validate_github_mapping
 from ai_provider import provider_template, validate_provider_registry
 from source_connection import resolve_github_token
@@ -21,6 +21,8 @@ from work_item_registry import validate_work_item_provider
 from ado_mcp import build_ado_mcp
 from worker_registry import build_worker, validate_worker_registry
 from framework_update import DEFAULT_FRAMEWORK_SOURCE, ensure_framework_metadata, build_update_plan, apply_update
+from instruction_adapter import adapter_for_provider, ensure_provider_instruction_file
+from planning_context import normalize_workspace
 
 
 DEFAULT_ROLE_PROVIDERS = {
@@ -32,7 +34,7 @@ DEFAULT_ROLE_PROVIDERS = {
     "RuntimeVerifierAgent": "project-defined",
 }
 
-PACKAGE_VERSION = "0.1.0"
+PACKAGE_VERSION = "0.2.0"
 
 ROLE_KEYS = {
     "SetupAgent": "setup",
@@ -385,6 +387,7 @@ def build_environment(environment: str, codespaces_mode: str) -> dict:
 
 
 def perform_init(args, ado_api_factory=AzureDevOps) -> tuple[dict, dict | None]:
+    root = Path(getattr(args, "root", "."))
     roles = parse_role_provider(args.role_provider)
     discovery = None
     if args.work_items == "azure-devops":
@@ -406,6 +409,8 @@ def perform_init(args, ado_api_factory=AzureDevOps) -> tuple[dict, dict | None]:
     )
 
     output = Path(args.output)
+    if not output.is_absolute():
+        output = root / output
     existing = _load_yaml(output) if output.exists() else {}
     config = generated if args.force or not existing else merge_owned(existing, generated)
     output.write_text(_dump_yaml(config), encoding="utf-8")
@@ -418,17 +423,17 @@ def perform_init(args, ado_api_factory=AzureDevOps) -> tuple[dict, dict | None]:
         )
 
     if not args.no_files:
-        ensure_file(Path("AGENTS.md"), generated_agents_md(), args.force)
-        ensure_file(Path("CURRENT.md"), generated_current_md(), args.force)
+        ensure_file(root / "AGENTS.md", generated_agents_md(), args.force)
+        ensure_file(root / "CURRENT.md", generated_current_md(), args.force)
         if args.environment == "codespaces":
             ensure_file(
-                Path(".devcontainer/devcontainer.json"),
+                root / ".devcontainer/devcontainer.json",
                 generated_devcontainer(),
                 args.force,
             )
         if args.work_items == "github-issues":
             ensure_file(
-                Path(".github/workflows/ai-workflow.yml"),
+                root / ".github/workflows/ai-workflow.yml",
                 generated_github_caller(args.framework_ref),
                 args.force,
             )
@@ -479,6 +484,20 @@ def init_ado(args) -> int:
 
 
 def setup_cmd(args) -> int:
+    if not args.non_interactive:
+        args = interactive_setup_options(args)
+
+    required = []
+    if args.work_items in ("github-issues", "composite") and not args.github_repository:
+        required.append("GitHub repository")
+    if args.work_items in ("azure-devops", "composite"):
+        if not args.ado_organization:
+            required.append("ADO organization")
+        if not args.ado_project:
+            required.append("ADO project")
+    if required:
+        raise RuntimeError("missing setup values: " + ", ".join(required))
+
     github_auth = None
     if args.github_repository:
         _, github_auth = resolve_github_token(args.github_auth, args.github_token_env)
@@ -536,12 +555,18 @@ def setup_cmd(args) -> int:
         ado_field_mapping=ado_field_mapping,
     )
     plan["work_items"]["mapping_confirmed"] = not args.plan_only
-    Path(args.plan_output).write_text(_dump_yaml(plan), encoding="utf-8")
+    plan_output = Path(args.plan_output)
+    if not plan_output.is_absolute():
+        plan_output = Path(args.root) / plan_output
+    plan_output.write_text(_dump_yaml(plan), encoding="utf-8")
     print(render_user_steps(plan))
-    print(f"\nWrote setup plan: {args.plan_output}")
+    print(f"\nWrote setup plan: {plan_output}")
 
     if args.plan_only:
         return 0
+    if not args.non_interactive and not confirm_setup_plan(plan):
+        print("Setup cancelled; no project configuration was applied.")
+        return 0
 
     if args.work_items == "github-issues":
         discovery, mapping, created = apply_github_status_bootstrap(args, mapping)
@@ -551,6 +576,7 @@ def setup_cmd(args) -> int:
     class InitArgs:
         pass
     init = InitArgs()
+    init.root = args.root
     init.work_items = "azure-devops" if args.work_items == "composite" else args.work_items
     init.ado_organization = args.ado_organization
     init.ado_project = args.ado_project
@@ -567,6 +593,20 @@ def setup_cmd(args) -> int:
     config["workflow"] = workflow
     config["providers"] = providers
     config["workers"] = workers
+    instruction_adapters = {}
+    if not args.no_files:
+        for provider_id, provider_config in providers.items():
+            provider_type = provider_config.get("type")
+            adapter = ensure_provider_instruction_file(args.root, provider_type)
+            instruction_adapters[provider_id] = {
+                key: value for key, value in adapter.items() if key != "changed"
+            }
+            if adapter.get("changed"):
+                print(f"Updated provider instruction adapter: {adapter.get('provider_file')}")
+    else:
+        for provider_id, provider_config in providers.items():
+            instruction_adapters[provider_id] = adapter_for_provider(provider_config.get("type"))
+    config["instruction_adapters"] = instruction_adapters
     config["source_connection"] = {"github": github_auth or {}}
     if ado_mcp:
         config["mcp"] = {"azure_devops": ado_mcp}
@@ -592,7 +632,23 @@ def setup_cmd(args) -> int:
     )
     config["framework"]["source"] = framework_source
     config["framework"]["ref"] = framework_version
-    Path(args.output).write_text(_dump_yaml(config), encoding="utf-8")
+    config_output = Path(args.output)
+    if not config_output.is_absolute():
+        config_output = Path(args.root) / config_output
+    config_output.write_text(_dump_yaml(config), encoding="utf-8")
+
+    workspace_config = getattr(args, "workspace_config", None)
+    if workspace_config:
+        normalized_workspace = normalize_workspace(workspace_config)
+        workspace_path = Path(args.root) / ".ai-workspace.yml"
+        workspace_path.write_text(_dump_yaml(workspace_config), encoding="utf-8")
+        config["planning_context"] = {
+            "workspace_file": ".ai-workspace.yml",
+            **normalized_workspace["planning_context"],
+        }
+        config_output.write_text(_dump_yaml(config), encoding="utf-8")
+        print(f"Wrote workspace registry: {workspace_path}")
+
     errors = doctor(config, discovery)
     if errors:
         print("Doctor findings:")
@@ -706,25 +762,25 @@ def main() -> int:
 
     setup = sub.add_parser("setup")
     setup.add_argument("--root", default=".")
-    setup.add_argument("--work-items", choices=["github-issues", "azure-devops", "composite"], default="github-issues")
+    setup.add_argument("--work-items", choices=["github-issues", "azure-devops", "composite"])
     setup.add_argument("--github-repository")
     setup.add_argument("--github-token-env", default="GH_TOKEN")
-    setup.add_argument("--github-auth", choices=["gh-cli","token-env"], default="gh-cli")
+    setup.add_argument("--github-auth", choices=["gh-cli","token-env"])
     setup.add_argument("--ado-organization")
     setup.add_argument("--ado-project")
     setup.add_argument("--ado-token-env", default="AZURE_DEVOPS_TOKEN")
-    setup.add_argument("--ado-mcp-mode", choices=["none","remote","local"], default="remote")
-    setup.add_argument("--ado-mcp-auth", choices=["interactive","azcli","env","envvar","pat"], default="interactive")
+    setup.add_argument("--ado-mcp-mode", choices=["none","remote","local"])
+    setup.add_argument("--ado-mcp-auth", choices=["interactive","azcli","env","envvar","pat"])
     setup.add_argument("--ado-team")
     setup.add_argument("--ado-field", action="append", default=[])
-    setup.add_argument("--environment", choices=["none", "codespaces"], default="none")
-    setup.add_argument("--codespaces-mode", choices=["off", "on-demand", "always-on"], default="on-demand")
+    setup.add_argument("--environment", choices=["none", "codespaces"])
+    setup.add_argument("--codespaces-mode", choices=["off", "on-demand", "always-on"])
     setup.add_argument("--role-provider", action="append", default=[])
     setup.add_argument("--ai-provider", action="append", default=[])
     setup.add_argument("--worker", action="append", default=[])
-    setup.add_argument("--tdd", action=argparse.BooleanOptionalAction, default=True)
-    setup.add_argument("--reviewer-mode", choices=["manual", "automatic", "none"], default="manual")
-    setup.add_argument("--runtime-mode", choices=["project-defined", "batched", "none"], default="project-defined")
+    setup.add_argument("--tdd", action=argparse.BooleanOptionalAction, default=None)
+    setup.add_argument("--reviewer-mode", choices=["manual", "automatic", "none"])
+    setup.add_argument("--runtime-mode", choices=["project-defined", "batched", "none"])
     setup.add_argument("--output", default=".ai-workflow.yml")
     setup.add_argument("--plan-output", default=".ai-setup-plan.yml")
     setup.add_argument("--framework-ref", default="vuthethienlong/ai-dev-workflow/.github/workflows/queue-dispatcher.yml@main")
@@ -749,11 +805,19 @@ def main() -> int:
     doc.set_defaults(func=doctor_cmd)
 
     args = parser.parse_args()
-    if args.command in ("init", "setup") and args.work_items in ("azure-devops", "composite"):
+    if args.command == "init" and args.work_items == "azure-devops":
         if not args.ado_organization or not args.ado_project:
             parser.error("--ado-organization and --ado-project are required for azure-devops")
-    if args.command == "setup" and args.work_items in ("github-issues", "composite") and not args.github_repository:
-        parser.error("--github-repository is required for GitHub status discovery")
+    if args.command == "setup" and args.non_interactive:
+        args.work_items = args.work_items or "github-issues"
+        args.github_auth = args.github_auth or "gh-cli"
+        args.ado_mcp_mode = args.ado_mcp_mode or "remote"
+        args.ado_mcp_auth = args.ado_mcp_auth or "interactive"
+        args.environment = args.environment or "none"
+        args.codespaces_mode = args.codespaces_mode or "on-demand"
+        args.tdd = True if args.tdd is None else args.tdd
+        args.reviewer_mode = args.reviewer_mode or "manual"
+        args.runtime_mode = args.runtime_mode or "project-defined"
     return args.func(args)
 
 

ai_dev_workflow-0.2.0/tools/instruction_adapter.py

@@ -0,0 +1,77 @@
+"""Provider-specific instruction file adapters.
+
+AGENTS.md is the shared provider-neutral source of truth.
+Provider-native files keep user-owned content; ai-dev-workflow only owns the
+bounded managed block below.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+START = "<!-- ai-dev-workflow:start -->"
+END = "<!-- ai-dev-workflow:end -->"
+
+ADAPTERS = {
+    "chatgpt-codex": {
+        "shared": "AGENTS.md",
+        "provider_file": None,
+        "merge_policy": "direct",
+    },
+    "anthropic": {
+        "shared": "AGENTS.md",
+        "provider_file": "CLAUDE.md",
+        "merge_policy": "preserve-existing",
+    },
+}
+
+
+def adapter_for_provider(provider_type: str) -> dict:
+    return dict(ADAPTERS.get(provider_type, {
+        "shared": "AGENTS.md",
+        "provider_file": None,
+        "merge_policy": "direct",
+    }))
+
+
+def managed_block() -> str:
+    return (
+        f"{START}\n"
+        "## Shared workflow instructions\n\n"
+        "Read and follow `AGENTS.md` as the shared project instruction source.\n\n"
+        "When you are executing an active ai-dev-workflow task and `CURRENT.md` "
+        "exists, read it as the short-lived task/context router. `CURRENT.md` is "
+        "not a permanent provider rule and is not required for unrelated sessions.\n"
+        f"{END}"
+    )
+
+
+def merge_managed_block(existing: str) -> str:
+    block = managed_block()
+    if START in existing or END in existing:
+        if START not in existing or END not in existing:
+            raise ValueError("instruction adapter managed block is malformed")
+        before, rest = existing.split(START, 1)
+        _, after = rest.split(END, 1)
+        return before + block + after
+
+    if not existing:
+        return block + "\n"
+    separator = "" if existing.endswith("\n\n") else ("\n" if existing.endswith("\n") else "\n\n")
+    return existing + separator + block + "\n"
+
+
+def ensure_provider_instruction_file(root: str | Path, provider_type: str) -> dict:
+    adapter = adapter_for_provider(provider_type)
+    provider_file = adapter.get("provider_file")
+    if not provider_file:
+        return {**adapter, "changed": False}
+
+    path = Path(root) / provider_file
+    existing = path.read_text(encoding="utf-8") if path.exists() else ""
+    merged = merge_managed_block(existing)
+    changed = merged != existing
+    if changed:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(merged, encoding="utf-8")
+
+    return {**adapter, "changed": changed}

ai_dev_workflow-0.2.0/tools/setup_wizard.py

@@ -0,0 +1,446 @@
+"""Step-by-step repository setup for ai-dev-workflow."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from ado_provider import AzureDevOps, build_state_mapping, available_fields
+from github_work_item_provider import GitHubIssues, build_github_mapping, ensure_managed_status_labels
+from setup_context import analyze_repository, setup_agent_context
+from ai_provider import credential_requirements_for_providers, provider_template
+from source_connection import resolve_github_token
+from ado_mcp import build_ado_mcp, ado_mcp_credentials
+from worker_registry import worker_credential_requirements
+
+CANONICAL_HELP = (
+    "draft, ready, in-progress, in-review, runtime-pending, "
+    "release-pending, blocked, completed"
+)
+
+DEFAULT_WORKFLOW = {
+    "tdd": True,
+    "reviewer": {"mode": "manual"},
+    "runtime_verification": {"mode": "project-defined"},
+}
+
+
+def credential_requirements(work_items: str, environment: str, agents: dict, providers: dict | None = None, github_auth=None, ado_mcp=None, workers: list[dict] | None = None) -> list[dict]:
+    requirements = []
+    if work_items in ("github-issues", "composite"):
+        if (github_auth or {}).get("type") == "gh-cli-oauth":
+            requirements.append({
+                "name": "GitHub CLI OAuth session",
+                "purpose": "Authenticate GitHub API through existing gh auth login session.",
+                "required_for_setup": True,
+                "store": "GitHub CLI credential store",
+            })
+        else:
+            requirements.append({
+                "name": (github_auth or {}).get("env", "GH_TOKEN"),
+                "purpose": "Authenticate GitHub API using token environment fallback.",
+                "required_for_setup": True,
+                "store": "environment or GitHub Actions secret; never commit",
+            })
+    if work_items in ("azure-devops", "composite"):
+        requirements.append({
+            "name": "AZURE_DEVOPS_TOKEN",
+            "purpose": "Discover ADO process/WIT states and manage work items.",
+            "required_for_setup": True,
+            "store": "environment/secret store; never commit",
+        })
+    if environment == "codespaces":
+        requirements.append({
+            "name": "CODESPACES_TOKEN",
+            "purpose": "Provision/start/stop GitHub Codespaces worker environments.",
+            "required_for_setup": False,
+            "store": "GitHub Actions repository secret",
+        })
+    requirements.extend(credential_requirements_for_providers(providers or {}))
+    requirements.extend(ado_mcp_credentials(ado_mcp or {}))
+    requirements.extend(worker_credential_requirements(workers or [], work_items))
+    return requirements
+
+
+def build_setup_plan(
+    root=".",
+    work_items="github-issues",
+    discovery=None,
+    mapping=None,
+    workflow=None,
+    agents=None,
+    environment=None,
+    providers=None,
+    github_auth=None,
+    ado_mcp=None,
+    workers=None,
+    ado_field_mapping=None,
+) -> dict:
+    analysis = analyze_repository(root)
+    if providers is None:
+        providers = {}
+        referenced = {item.get("provider") for item in (agents or {}).values() if isinstance(item, dict)}
+        if "codex" in referenced:
+            providers["codex"] = provider_template("chatgpt-codex")
+        if "manual" in referenced:
+            providers["manual"] = provider_template("interactive")
+    return {
+        "version": 1,
+        "status": "review-required",
+        "phases": [
+            {"id": 1, "name": "connect-source-host", "status": "complete"},
+            {"id": 2, "name": "analyze-context", "status": "complete"},
+            {"id": 3, "name": "select-work-item-provider", "status": "complete"},
+            {"id": 4, "name": "connect-work-item-provider", "status": "complete"},
+            {"id": 5, "name": "discover-existing-statuses", "status": "complete" if discovery is not None else "pending"},
+            {"id": 6, "name": "confirm-status-mapping", "status": "review-required"},
+            {"id": 7, "name": "configure-workflow-and-agents", "status": "review-required"},
+            {"id": 8, "name": "register-workers", "status": "review-required"},
+            {"id": 9, "name": "configure-environment-and-credentials", "status": "review-required"},
+            {"id": 10, "name": "doctor-and-apply", "status": "pending"},
+        ],
+        "context": analysis,
+        "setup_agent": setup_agent_context(analysis),
+        "source_connection": {"github": github_auth or {}},
+        "work_items": {
+            "provider": work_items,
+            "discovery": discovery,
+            "suggested_mapping": mapping or {},
+            "mapping_confirmed": False,
+            "ado_field_mapping": ado_field_mapping or {},
+        },
+        "workflow": workflow or DEFAULT_WORKFLOW,
+        "agents": agents or {},
+        "providers": providers or {},
+        "ado_mcp": ado_mcp or {},
+        "workers": workers or [],
+        "execution_environment": environment or {"type": "none"},
+        "credential_requirements": credential_requirements(
+            work_items,
+            (environment or {"type": "none"}).get("type", "none"),
+            agents or {},
+            providers or {},
+            github_auth,
+            ado_mcp,
+            workers or [],
+        ),
+    }
+
+
+def discover_provider(args):
+    if args.work_items in ("azure-devops", "composite"):
+        token = os.environ.get(args.ado_token_env)
+        if not token:
+            raise RuntimeError(f"{args.ado_token_env} is required for ADO discovery")
+        discovery = AzureDevOps(args.ado_organization, token).discover(args.ado_project)
+        return discovery, build_state_mapping(discovery)
+
+    token, _ = resolve_github_token(args.github_auth, args.github_token_env)
+    discovery = GitHubIssues(args.github_repository, token).discover()
+    return discovery, build_github_mapping(discovery)
+
+
+def interactive_ado_field_mapping(discovery: dict, input_fn=input, output_fn=print) -> dict:
+    result = {}
+    output_fn("\nADO existing-field mapping (existing fields only; setup will not create fields)")
+    for wit in discovery.get("work_item_types", []):
+        ref = wit["reference_name"]
+        fields = available_fields(discovery, ref)
+        if not fields:
+            continue
+        output_fn(f"\nWork Item Type: {wit['name']} ({ref})")
+        by_ref = {f["reference_name"]: f for f in fields}
+        configured = {}
+        for key in ("workflow_phase","github_issue","worker","agent_role","pull_request","test_status","runtime_status","workflow_profile"):
+            field_ref = input_fn(f"  Map {key} to existing field reference (blank=skip): ").strip()
+            if not field_ref:
+                continue
+            if field_ref not in by_ref:
+                raise ValueError(f"ADO field does not exist for {ref}: {field_ref}")
+            default = input_fn(f"    Default value for {key} (blank=no default): ")
+            item = {"field": field_ref}
+            if default != "":
+                item["default"] = default
+            configured[key] = item
+        if configured:
+            result[ref] = configured
+    return result
+
+
+def interactive_mapping(provider: str, discovery: dict, suggestions: dict, input_fn=input, output_fn=print):
+    output_fn(f"Canonical states: {CANONICAL_HELP}")
+    if provider == "azure-devops":
+        result = {}
+        for wit in discovery.get("work_item_types", []):
+            ref = wit["reference_name"]
+            result[ref] = {}
+            output_fn(f"\nWork Item Type: {wit['name']} ({ref})")
+            for state in wit.get("states", []):
+                if state.get("hidden"):
+                    continue
+                name = state["name"]
+                default = suggestions.get(ref, {}).get(name, "draft")
+                value = input_fn(f"  {name} [{default}]: ").strip() or default
+                result[ref][name] = value
+        return result
+
+    result = {}
+    labels = discovery.get("labels", [])
+    for item in labels:
+        name = item["name"]
+        default = suggestions.get(name)
+        prompt_default = default or "skip"
+        value = input_fn(f"  {name} [{prompt_default}]: ").strip()
+        if not value:
+            value = default
+        if value and value != "skip":
+            result[name] = value
+    return result
+
+
+def apply_github_status_bootstrap(args, mapping: dict) -> tuple[dict, dict, list[str]]:
+    token, _ = resolve_github_token(args.github_auth, args.github_token_env)
+    api = GitHubIssues(args.github_repository, token)
+    before = api.discover()
+    created = ensure_managed_status_labels(api, before)
+    after = api.discover() if created else before
+    refreshed = build_github_mapping(after)
+    refreshed.update(mapping)
+    return after, refreshed, created
+
+
+def render_user_steps(plan: dict) -> str:
+    lines = ["Setup phases:"]
+    for phase in plan["phases"]:
+        lines.append(f"{phase['id']}. {phase['name']} — {phase['status']}")
+    lines.append("")
+    lines.append("Manual credential/settings checklist:")
+    if not plan["credential_requirements"]:
+        lines.append("- none")
+    for item in plan["credential_requirements"]:
+        lines.append(f"- {item['name']}: {item['purpose']} Store: {item['store']}.")
+    return "\n".join(lines)
+
+
+def _prompt(input_fn, text: str, default: str | None = None) -> str:
+    suffix = f" [{default}]" if default not in (None, "") else ""
+    value = input_fn(f"{text}{suffix}: ").strip()
+    return value if value else (default or "")
+
+
+def _choice(input_fn, output_fn, title: str, options: list[tuple[str, str]], default: str) -> str:
+    output_fn(title)
+    by_number = {}
+    allowed = set()
+    for index, (value, label) in enumerate(options, 1):
+        by_number[str(index)] = value
+        allowed.add(value)
+        marker = " (default)" if value == default else ""
+        output_fn(f"  {index}. {label}{marker}")
+    while True:
+        raw = _prompt(input_fn, "Choose", default)
+        value = by_number.get(raw, raw)
+        if value in allowed:
+            return value
+        output_fn("Invalid choice. Try again.")
+
+
+def _yes_no(input_fn, text: str, default: bool = False) -> bool:
+    hint = "Y/n" if default else "y/N"
+    raw = input_fn(f"{text} [{hint}]: ").strip().lower()
+    if not raw:
+        return default
+    return raw in ("y", "yes", "1", "true", "on")
+
+
+def interactive_setup_options(args, input_fn=input, output_fn=print):
+    """Collect a complete setup configuration while preserving explicit CLI flags."""
+    output_fn("ai-dev-workflow setup wizard")
+    output_fn("Press Enter to accept the value shown in brackets.\n")
+
+    args.root = _prompt(input_fn, "1/9 Project root", args.root or ".")
+    args.work_items = args.work_items or _choice(
+        input_fn, output_fn, "2/9 Work Item Provider",
+        [
+            ("github-issues", "GitHub Issues only"),
+            ("azure-devops", "Azure DevOps only"),
+            ("composite", "Azure DevOps business items + GitHub execution issues"),
+        ],
+        "github-issues",
+    )
+
+    if args.work_items in ("github-issues", "composite"):
+        args.github_repository = args.github_repository or _prompt(
+            input_fn, "3/9 GitHub repository (owner/repo)"
+        )
+        args.github_auth = args.github_auth or _choice(
+            input_fn, output_fn, "GitHub authentication",
+            [("gh-cli", "GitHub CLI login (recommended)"), ("token-env", "Token environment variable")],
+            "gh-cli",
+        )
+        if args.github_auth == "token-env":
+            args.github_token_env = _prompt(input_fn, "GitHub token env", args.github_token_env or "GH_TOKEN")
+
+    if args.work_items in ("azure-devops", "composite"):
+        output_fn("4/9 Azure DevOps settings")
+        args.ado_organization = args.ado_organization or _prompt(input_fn, "ADO organization")
+        args.ado_project = args.ado_project or _prompt(input_fn, "ADO project")
+        args.ado_token_env = _prompt(input_fn, "ADO token env", args.ado_token_env or "AZURE_DEVOPS_TOKEN")
+        args.ado_mcp_mode = args.ado_mcp_mode or _choice(
+            input_fn, output_fn, "ADO MCP mode",
+            [("none", "Disabled"), ("remote", "Remote MCP"), ("local", "Local MCP")],
+            "remote",
+        )
+        if args.ado_mcp_mode != "none":
+            args.ado_mcp_auth = args.ado_mcp_auth or _choice(
+                input_fn, output_fn, "ADO MCP authentication",
+                [
+                    ("interactive", "Interactive"),
+                    ("azcli", "Azure CLI"),
+                    ("env", "Environment"),
+                    ("envvar", "Environment variable"),
+                    ("pat", "PAT"),
+                ],
+                "interactive",
+            )
+
+    workspace = interactive_workspace_options(args, input_fn=input_fn, output_fn=output_fn)
+    args.workspace_config = workspace
+
+    output_fn("5/10 AI providers")
+    if not args.ai_provider and _yes_no(input_fn, "Add Claude Code / Anthropic provider?", False):
+        provider_id = _prompt(input_fn, "Provider id", "claude")
+        env = _prompt(input_fn, "Anthropic API key env", "ANTHROPIC_API_KEY")
+        args.ai_provider.append(f"{provider_id}=anthropic,auth=api-key-env,env={env}")
+
+    output_fn("6/10 Agent role assignment")
+    role_defaults = {
+        "SetupAgent": "manual",
+        "ArchitectAgent": "manual",
+        "TesterAgent": "codex",
+        "ImplementerAgent": "codex",
+        "ReviewerAgent": "manual",
+        "RuntimeVerifierAgent": "project-defined",
+    }
+    if not args.role_provider:
+        for role, default in role_defaults.items():
+            provider = _prompt(input_fn, f"{role} provider", default)
+            args.role_provider.append(f"{role}={provider}")
+
+    output_fn("7/10 Workers")
+    if not args.worker:
+        while _yes_no(input_fn, "Register a worker?", False):
+            worker_id = _prompt(input_fn, "Worker id")
+            mode = _choice(
+                input_fn, output_fn, "Worker mode",
+                [("planner", "Planner"), ("executor", "Executor"), ("hybrid", "Hybrid")],
+                "hybrid",
+            )
+            provider = _prompt(input_fn, "Provider id", "codex")
+            environment = _choice(
+                input_fn, output_fn, "Worker environment",
+                [("local", "Local"), ("codespaces", "GitHub Codespaces"), ("cloud", "Cloud")],
+                "local",
+            )
+            if mode == "planner":
+                default_roles = "SetupAgent|ArchitectAgent|ReviewerAgent"
+            elif mode == "executor":
+                default_roles = "TesterAgent|ImplementerAgent|RuntimeVerifierAgent"
+            else:
+                default_roles = "ArchitectAgent|TesterAgent|ImplementerAgent|ReviewerAgent"
+            roles = _prompt(input_fn, "Roles separated by |", default_roles)
+            capacity = _prompt(input_fn, "Capacity", "1")
+            parts = [mode, f"provider={provider}", f"environment={environment}", f"roles={roles}", f"capacity={capacity}"]
+            if environment == "local" and mode in ("executor", "hybrid"):
+                assignee = _prompt(input_fn, "GitHub/Work Item assignee for local claim ownership")
+                if assignee:
+                    parts.append(f"assignee={assignee}")
+                parts.append("managed=false")
+            args.worker.append(f"{worker_id}=" + ",".join(parts))
+
+    args.environment = args.environment or _choice(
+        input_fn, output_fn, "8/10 Framework execution environment",
+        [("none", "No managed environment"), ("codespaces", "GitHub Codespaces")],
+        "none",
+    )
+    if args.environment == "codespaces":
+        args.codespaces_mode = args.codespaces_mode or _choice(
+            input_fn, output_fn, "Codespaces mode",
+            [("off", "Off"), ("on-demand", "On demand"), ("always-on", "Always on")],
+            "on-demand",
+        )
+
+    output_fn("9/10 Workflow policy")
+    if args.tdd is None:
+        args.tdd = _yes_no(input_fn, "Require TDD/test design", True)
+    args.reviewer_mode = args.reviewer_mode or _choice(
+        input_fn, output_fn, "Reviewer mode",
+        [("manual", "Manual"), ("automatic", "Automatic"), ("none", "Disabled")],
+        "manual",
+    )
+    args.runtime_mode = args.runtime_mode or _choice(
+        input_fn, output_fn, "Runtime verification",
+        [("project-defined", "Project-defined"), ("batched", "Batched runtime verification"), ("none", "Disabled")],
+        "project-defined",
+    )
+    output_fn("10/10 Review will be shown after provider discovery and status mapping.")
+    return args
+
+
+def confirm_setup_plan(plan: dict, input_fn=input, output_fn=print) -> bool:
+    output_fn("\nReview")
+    output_fn(f"- Work Item Provider: {plan['work_items']['provider']}")
+    output_fn(f"- AI providers: {', '.join(plan.get('providers', {}).keys()) or 'none'}")
+    output_fn(f"- Workers: {len(plan.get('workers', []))}")
+    output_fn(f"- Environment: {plan.get('execution_environment', {}).get('type', 'none')}")
+    workflow = plan.get("workflow", {})
+    output_fn(f"- TDD: {workflow.get('tdd')}")
+    output_fn(f"- Reviewer: {(workflow.get('reviewer') or {}).get('mode')}")
+    output_fn(f"- Runtime verification: {(workflow.get('runtime_verification') or {}).get('mode')}")
+    return _yes_no(input_fn, "Apply this configuration?", True)
+
+
+def interactive_workspace_options(args, input_fn=input, output_fn=print) -> dict | None:
+    """Collect optional multi-repository workspace configuration."""
+    if not _yes_no(input_fn, "Use a multi-repository workspace?", False):
+        return None
+
+    output_fn("\nMulti-repository workspace")
+    name = _prompt(input_fn, "Workspace name", "ai-workspace")
+    repositories = []
+
+    primary_repo = args.github_repository or _prompt(input_fn, "Primary repository (owner/repo)")
+    primary_ref = _prompt(input_fn, "Primary repository ref", "main")
+    repositories.append({
+        "repository": primary_repo,
+        "purpose": _prompt(input_fn, "Primary repository purpose", "primary-application"),
+        "ref": primary_ref,
+        "access": "read-write",
+        "context": ["AGENTS.md", "CURRENT.md", "docs/**"],
+    })
+
+    while _yes_no(input_fn, "Add another repository?", False):
+        repository = _prompt(input_fn, "Repository (owner/repo)")
+        purpose = _prompt(input_fn, "Purpose", "shared-dependency")
+        ref = _prompt(input_fn, "Ref", "main")
+        access = _choice(
+            input_fn, output_fn, "Access",
+            [("read", "Read only"), ("read-write", "Read/write")],
+            "read",
+        )
+        context_raw = _prompt(input_fn, "Context paths separated by |", "AGENTS.md|docs/**")
+        repositories.append({
+            "repository": repository,
+            "purpose": purpose,
+            "ref": ref,
+            "access": access,
+            "context": [item for item in context_raw.split("|") if item],
+        })
+
+    default_repository = _prompt(input_fn, "Default planning repository", primary_repo)
+    return {
+        "version": 1,
+        "workspace": {"name": name},
+        "repositories": repositories,
+        "planning": {"default_repository": default_repository},
+        "initiatives": {},
+    }

ai_dev_workflow-0.1.0/tools/setup_wizard.py

@@ -1,221 +0,0 @@
-"""Step-by-step repository setup for ai-dev-workflow."""
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-from ado_provider import AzureDevOps, build_state_mapping, available_fields
-from github_work_item_provider import GitHubIssues, build_github_mapping, ensure_managed_status_labels
-from setup_context import analyze_repository, setup_agent_context
-from ai_provider import credential_requirements_for_providers, provider_template
-from source_connection import resolve_github_token
-from ado_mcp import build_ado_mcp, ado_mcp_credentials
-from worker_registry import worker_credential_requirements
-
-CANONICAL_HELP = (
-    "draft, ready, in-progress, in-review, runtime-pending, "
-    "release-pending, blocked, completed"
-)
-
-DEFAULT_WORKFLOW = {
-    "tdd": True,
-    "reviewer": {"mode": "manual"},
-    "runtime_verification": {"mode": "project-defined"},
-}
-
-
-def credential_requirements(work_items: str, environment: str, agents: dict, providers: dict | None = None, github_auth=None, ado_mcp=None, workers: list[dict] | None = None) -> list[dict]:
-    requirements = []
-    if work_items in ("github-issues", "composite"):
-        if (github_auth or {}).get("type") == "gh-cli-oauth":
-            requirements.append({
-                "name": "GitHub CLI OAuth session",
-                "purpose": "Authenticate GitHub API through existing gh auth login session.",
-                "required_for_setup": True,
-                "store": "GitHub CLI credential store",
-            })
-        else:
-            requirements.append({
-                "name": (github_auth or {}).get("env", "GH_TOKEN"),
-                "purpose": "Authenticate GitHub API using token environment fallback.",
-                "required_for_setup": True,
-                "store": "environment or GitHub Actions secret; never commit",
-            })
-    if work_items in ("azure-devops", "composite"):
-        requirements.append({
-            "name": "AZURE_DEVOPS_TOKEN",
-            "purpose": "Discover ADO process/WIT states and manage work items.",
-            "required_for_setup": True,
-            "store": "environment/secret store; never commit",
-        })
-    if environment == "codespaces":
-        requirements.append({
-            "name": "CODESPACES_TOKEN",
-            "purpose": "Provision/start/stop GitHub Codespaces worker environments.",
-            "required_for_setup": False,
-            "store": "GitHub Actions repository secret",
-        })
-    requirements.extend(credential_requirements_for_providers(providers or {}))
-    requirements.extend(ado_mcp_credentials(ado_mcp or {}))
-    requirements.extend(worker_credential_requirements(workers or [], work_items))
-    return requirements
-
-
-def build_setup_plan(
-    root=".",
-    work_items="github-issues",
-    discovery=None,
-    mapping=None,
-    workflow=None,
-    agents=None,
-    environment=None,
-    providers=None,
-    github_auth=None,
-    ado_mcp=None,
-    workers=None,
-    ado_field_mapping=None,
-) -> dict:
-    analysis = analyze_repository(root)
-    if providers is None:
-        providers = {}
-        referenced = {item.get("provider") for item in (agents or {}).values() if isinstance(item, dict)}
-        if "codex" in referenced:
-            providers["codex"] = provider_template("chatgpt-codex")
-        if "manual" in referenced:
-            providers["manual"] = provider_template("interactive")
-    return {
-        "version": 1,
-        "status": "review-required",
-        "phases": [
-            {"id": 1, "name": "connect-source-host", "status": "complete"},
-            {"id": 2, "name": "analyze-context", "status": "complete"},
-            {"id": 3, "name": "select-work-item-provider", "status": "complete"},
-            {"id": 4, "name": "connect-work-item-provider", "status": "complete"},
-            {"id": 5, "name": "discover-existing-statuses", "status": "complete" if discovery is not None else "pending"},
-            {"id": 6, "name": "confirm-status-mapping", "status": "review-required"},
-            {"id": 7, "name": "configure-workflow-and-agents", "status": "review-required"},
-            {"id": 8, "name": "register-workers", "status": "review-required"},
-            {"id": 9, "name": "configure-environment-and-credentials", "status": "review-required"},
-            {"id": 10, "name": "doctor-and-apply", "status": "pending"},
-        ],
-        "context": analysis,
-        "setup_agent": setup_agent_context(analysis),
-        "source_connection": {"github": github_auth or {}},
-        "work_items": {
-            "provider": work_items,
-            "discovery": discovery,
-            "suggested_mapping": mapping or {},
-            "mapping_confirmed": False,
-            "ado_field_mapping": ado_field_mapping or {},
-        },
-        "workflow": workflow or DEFAULT_WORKFLOW,
-        "agents": agents or {},
-        "providers": providers or {},
-        "ado_mcp": ado_mcp or {},
-        "workers": workers or [],
-        "execution_environment": environment or {"type": "none"},
-        "credential_requirements": credential_requirements(
-            work_items,
-            (environment or {"type": "none"}).get("type", "none"),
-            agents or {},
-            providers or {},
-            github_auth,
-            ado_mcp,
-            workers or [],
-        ),
-    }
-
-
-def discover_provider(args):
-    if args.work_items in ("azure-devops", "composite"):
-        token = os.environ.get(args.ado_token_env)
-        if not token:
-            raise RuntimeError(f"{args.ado_token_env} is required for ADO discovery")
-        discovery = AzureDevOps(args.ado_organization, token).discover(args.ado_project)
-        return discovery, build_state_mapping(discovery)
-
-    token, _ = resolve_github_token(args.github_auth, args.github_token_env)
-    discovery = GitHubIssues(args.github_repository, token).discover()
-    return discovery, build_github_mapping(discovery)
-
-
-def interactive_ado_field_mapping(discovery: dict, input_fn=input, output_fn=print) -> dict:
-    result = {}
-    output_fn("\nADO existing-field mapping (existing fields only; setup will not create fields)")
-    for wit in discovery.get("work_item_types", []):
-        ref = wit["reference_name"]
-        fields = available_fields(discovery, ref)
-        if not fields:
-            continue
-        output_fn(f"\nWork Item Type: {wit['name']} ({ref})")
-        by_ref = {f["reference_name"]: f for f in fields}
-        configured = {}
-        for key in ("workflow_phase","github_issue","worker","agent_role","pull_request","test_status","runtime_status","workflow_profile"):
-            field_ref = input_fn(f"  Map {key} to existing field reference (blank=skip): ").strip()
-            if not field_ref:
-                continue
-            if field_ref not in by_ref:
-                raise ValueError(f"ADO field does not exist for {ref}: {field_ref}")
-            default = input_fn(f"    Default value for {key} (blank=no default): ")
-            item = {"field": field_ref}
-            if default != "":
-                item["default"] = default
-            configured[key] = item
-        if configured:
-            result[ref] = configured
-    return result
-
-
-def interactive_mapping(provider: str, discovery: dict, suggestions: dict, input_fn=input, output_fn=print):
-    output_fn(f"Canonical states: {CANONICAL_HELP}")
-    if provider == "azure-devops":
-        result = {}
-        for wit in discovery.get("work_item_types", []):
-            ref = wit["reference_name"]
-            result[ref] = {}
-            output_fn(f"\nWork Item Type: {wit['name']} ({ref})")
-            for state in wit.get("states", []):
-                if state.get("hidden"):
-                    continue
-                name = state["name"]
-                default = suggestions.get(ref, {}).get(name, "draft")
-                value = input_fn(f"  {name} [{default}]: ").strip() or default
-                result[ref][name] = value
-        return result
-
-    result = {}
-    labels = discovery.get("labels", [])
-    for item in labels:
-        name = item["name"]
-        default = suggestions.get(name)
-        prompt_default = default or "skip"
-        value = input_fn(f"  {name} [{prompt_default}]: ").strip()
-        if not value:
-            value = default
-        if value and value != "skip":
-            result[name] = value
-    return result
-
-
-def apply_github_status_bootstrap(args, mapping: dict) -> tuple[dict, dict, list[str]]:
-    token, _ = resolve_github_token(args.github_auth, args.github_token_env)
-    api = GitHubIssues(args.github_repository, token)
-    before = api.discover()
-    created = ensure_managed_status_labels(api, before)
-    after = api.discover() if created else before
-    refreshed = build_github_mapping(after)
-    refreshed.update(mapping)
-    return after, refreshed, created
-
-
-def render_user_steps(plan: dict) -> str:
-    lines = ["Setup phases:"]
-    for phase in plan["phases"]:
-        lines.append(f"{phase['id']}. {phase['name']} — {phase['status']}")
-    lines.append("")
-    lines.append("Manual credential/settings checklist:")
-    if not plan["credential_requirements"]:
-        lines.append("- none")
-    for item in plan["credential_requirements"]:
-        lines.append(f"- {item['name']}: {item['purpose']} Store: {item['store']}.")
-    return "\n".join(lines)