norn-cli 0.7.1__tar.gz → 0.7.2__tar.gz

{norn_cli-0.7.1 → norn_cli-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: norn-cli
-Version: 0.7.1
+Version: 0.7.2
 Summary: Norn: a provider-neutral multi-agent development harness
 License-Expression: Apache-2.0
 Project-URL: Repository, https://github.com/uruca-kk/norn
@@ -70,6 +70,17 @@ assigned evidence directory. The harness rejects missing, stale, symlinked, or
 out-of-directory evidence and archives accepted files under
 `.norf/runs/<run-id>/artifacts/e2e/`.
 
+To implement a previously approved plan without invoking orchestration, planning,
+or plan review again, pass the successful `plan` run ID with the identical request:
+
+```bash
+norn plan "add an audit log"
+norn run "add an audit log" --from-plan <plan-run-id>
+```
+
+Norn verifies the source run mode and status, project root, request text, and saved
+artifact schemas before creating the implementation worktree.
+
 For Codex tester roles, the adapter keeps `workspace-write` filesystem isolation
 and enables command networking through a loopback-only proxy allowlist
 (`localhost` and `127.0.0.1`). Planning and implementation roles retain their
@@ -124,7 +135,7 @@ ruff format --check .
 ruff check .
 python3 -m unittest discover -v
 python3 -m build
-python3 scripts/package_smoke.py dist/norn_cli-0.7.1-py3-none-any.whl
+python3 scripts/package_smoke.py dist/norn_cli-0.7.2-py3-none-any.whl
 ```
 
 CI runs the quality suite on Python 3.12, 3.13, and 3.14, then installs the

{norn_cli-0.7.1 → norn_cli-0.7.2}/README.md

@@ -45,6 +45,17 @@ assigned evidence directory. The harness rejects missing, stale, symlinked, or
 out-of-directory evidence and archives accepted files under
 `.norf/runs/<run-id>/artifacts/e2e/`.
 
+To implement a previously approved plan without invoking orchestration, planning,
+or plan review again, pass the successful `plan` run ID with the identical request:
+
+```bash
+norn plan "add an audit log"
+norn run "add an audit log" --from-plan <plan-run-id>
+```
+
+Norn verifies the source run mode and status, project root, request text, and saved
+artifact schemas before creating the implementation worktree.
+
 For Codex tester roles, the adapter keeps `workspace-write` filesystem isolation
 and enables command networking through a loopback-only proxy allowlist
 (`localhost` and `127.0.0.1`). Planning and implementation roles retain their
@@ -99,7 +110,7 @@ ruff format --check .
 ruff check .
 python3 -m unittest discover -v
 python3 -m build
-python3 scripts/package_smoke.py dist/norn_cli-0.7.1-py3-none-any.whl
+python3 scripts/package_smoke.py dist/norn_cli-0.7.2-py3-none-any.whl
 ```
 
 CI runs the quality suite on Python 3.12, 3.13, and 3.14, then installs the

{norn_cli-0.7.1 → norn_cli-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "norn-cli"
-version = "0.7.1"
+version = "0.7.2"
 description = "Norn: a provider-neutral multi-agent development harness"
 readme = "README.md"
 license = "Apache-2.0"

{norn_cli-0.7.1 → norn_cli-0.7.2}/src/norf_harness/__init__.py

@@ -3,4 +3,4 @@
 from .config import HarnessConfig, load_config
 
 __all__ = ["HarnessConfig", "load_config"]
-__version__ = "0.7.1"
+__version__ = "0.7.2"

{norn_cli-0.7.1 → norn_cli-0.7.2}/src/norf_harness/cli.py

@@ -53,11 +53,21 @@ def build_parser() -> argparse.ArgumentParser:
     _common_options(providers_parser)
     providers_parser.add_argument("--json", action="store_true", dest="json_output")
 
-    for name in ("plan", "run"):
-        execution = subparsers.add_parser(name, help=f"start a {name} lifecycle")
-        execution.add_argument("request")
-        _common_options(execution)
-        _limit_options(execution)
+    plan_parser = subparsers.add_parser("plan", help="start a plan lifecycle")
+    plan_parser.add_argument("request")
+    _common_options(plan_parser)
+    _limit_options(plan_parser)
+
+    run_parser = subparsers.add_parser("run", help="start a run lifecycle")
+    run_parser.add_argument("request")
+    run_parser.add_argument(
+        "--from-plan",
+        dest="plan_run_id",
+        metavar="RUN_ID",
+        help="reuse the approved plan from a successful plan run",
+    )
+    _common_options(run_parser)
+    _limit_options(run_parser)
 
     for name in ("status", "recover", "report"):
         command = subparsers.add_parser(name)
@@ -106,7 +116,12 @@ def main(argv: list[str] | None = None) -> int:
         if args.command == "providers":
             return _providers(config, args.json_output)
         if args.command in {"plan", "run"}:
-            return _execution(config, args.request, RunMode(args.command))
+            return _execution(
+                config,
+                args.request,
+                RunMode(args.command),
+                plan_run_id=getattr(args, "plan_run_id", None),
+            )
         if args.command == "status":
             return _status(config, args.run_id, args.json_output)
         if args.command == "recover":
@@ -227,8 +242,8 @@ def _providers(config, json_output: bool) -> int:
     return 1 if failed else 0
 
 
-def _execution(config, request: str, mode: RunMode) -> int:
-    outcome = asyncio.run(execute_pipeline(config, request, mode))
+def _execution(config, request: str, mode: RunMode, *, plan_run_id: str | None = None) -> int:
+    outcome = asyncio.run(execute_pipeline(config, request, mode, plan_run_id=plan_run_id))
     manifest = outcome.manifest
     if manifest.exit_code == 0:
         print(f"Harness succeeded: {outcome.paths.final_report}")

{norn_cli-0.7.1 → norn_cli-0.7.2}/src/norf_harness/pipeline.py

@@ -8,6 +8,8 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Protocol
 
+import jsonschema
+
 from .config import HarnessConfig
 from .e2e_evidence import EvidenceError, prepare_evidence_directory, validate_and_archive_e2e
 from .gate import Finding, GateResult, Severity, evaluate_gate
@@ -17,7 +19,7 @@ from .providers import default_registry
 from .providers.base import ErrorKind, ProviderError, ProviderRequest, SandboxPolicy
 from .providers.router import ProviderRouter, ProviderRoutingError, RoutedResult
 from .reporting import write_reports
-from .run_store import RunPaths, RunStore
+from .run_store import RunPaths, RunStore, RunStoreError
 from .worktree import WorktreeError, prepare_worktree
 
 
@@ -186,11 +188,18 @@ async def execute_pipeline(
     mode: RunMode,
     *,
     router: Router | None = None,
+    plan_run_id: str | None = None,
 ) -> PipelineOutcome:
     store = RunStore(config)
     manifest, paths = store.create(request, mode)
-    store.start(manifest, phase="orchestration")
+    store.start(
+        manifest,
+        phase="plan_reuse_validation" if plan_run_id is not None else "orchestration",
+    )
     try:
+        reused_plan = (
+            _load_approved_plan(store, manifest, plan_run_id) if plan_run_id is not None else None
+        )
         execution_config = (
             prepare_worktree(config, manifest, store) if mode == RunMode.RUN else config
         )
@@ -200,7 +209,7 @@ async def execute_pipeline(
             manifest,
             router or ProviderRouter(execution_config, default_registry()),
         )
-        await runner.run(mode)
+        await runner.run(mode, reused_plan=reused_plan, plan_run_id=plan_run_id)
     except PipelineStop as stop:
         store.escalate(
             manifest,
@@ -263,6 +272,98 @@ async def execute_pipeline(
     return PipelineOutcome(manifest, paths)
 
 
+def _load_approved_plan(
+    store: RunStore,
+    manifest: RunManifest,
+    plan_run_id: str,
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    if manifest.mode != RunMode.RUN:
+        raise PipelineStop(
+            StopReason.UNSAFE_OPERATION_BLOCKED,
+            ExitCode.MANUAL_DECISION_REQUIRED,
+            "承認済みplanの再利用はrun lifecycleでのみ指定できます。",
+            ("--from-planはnorn runで指定する",),
+        )
+    try:
+        source_paths = store.paths(plan_run_id)
+        _reject_symlinked_plan_source(store, source_paths)
+        source = store.load_manifest(plan_run_id)
+        plan = _read_plan_artifact(store, plan_run_id, "approved-plan.json")
+        orchestration = _read_plan_artifact(
+            store,
+            plan_run_id,
+            "approved-orchestration.json",
+        )
+        if orchestration is None:
+            legacy = _read_plan_artifact(store, plan_run_id, "001-orchestrator.json")
+            if isinstance(legacy, dict):
+                orchestration = legacy.get("result")
+    except RunStoreError as exc:
+        raise PipelineStop(
+            StopReason.MANUAL_DECISION_REQUIRED,
+            ExitCode.MANUAL_DECISION_REQUIRED,
+            f"再利用するplan runを読み込めません: {exc}",
+            ("正しいplan run IDを確認する",),
+        ) from exc
+
+    problems: list[str] = []
+    if source.mode != RunMode.PLAN:
+        problems.append("source runはplan modeではありません")
+    if source.status != "succeeded" or source.exit_code != 0:
+        problems.append("source plan runは正常完了していません")
+    if Path(source.project_root).resolve() != store.config.project_root.resolve():
+        problems.append("source plan runのproject rootが現在のprojectと一致しません")
+    if source.request != manifest.request:
+        problems.append("source plan runの依頼文が現在の依頼文と一致しません")
+    if plan is None:
+        problems.append("approved-plan.jsonがありません")
+    if orchestration is None:
+        problems.append("承認済みplanに対応するorchestration成果物がありません")
+    if problems:
+        raise PipelineStop(
+            StopReason.MANUAL_DECISION_REQUIRED,
+            ExitCode.MANUAL_DECISION_REQUIRED,
+            "承認済みplanを安全に再利用できません: " + "; ".join(problems),
+            ("同じprojectと依頼文で正常完了したplan runを指定する",),
+        )
+
+    try:
+        jsonschema.validate(plan, _PLAN_SCHEMA)
+        jsonschema.validate(orchestration, _ORCHESTRATION_SCHEMA)
+    except jsonschema.ValidationError as exc:
+        raise PipelineStop(
+            StopReason.MANUAL_DECISION_REQUIRED,
+            ExitCode.MANUAL_DECISION_REQUIRED,
+            f"保存済みplan成果物が期待する形式ではありません: {exc.message}",
+            ("source plan runの成果物を確認し、新しいplanを作成する",),
+        ) from exc
+
+    store.write_json(
+        manifest.run_id,
+        "artifacts/reused-plan.json",
+        {
+            "source_run_id": plan_run_id,
+            "orchestration": orchestration,
+            "plan": plan,
+        },
+    )
+    return orchestration, plan
+
+
+def _reject_symlinked_plan_source(store: RunStore, paths: RunPaths) -> None:
+    candidates = (store.config.runs_dir, paths.root, paths.manifest, paths.artifacts)
+    symlink = next((path for path in candidates if path.is_symlink()), None)
+    if symlink is not None:
+        raise RunStoreError(f"Plan source path must not be a symlink: {symlink}")
+
+
+def _read_plan_artifact(store: RunStore, run_id: str, name: str) -> Any:
+    path = store.paths(run_id).artifacts / name
+    if path.is_symlink():
+        raise RunStoreError(f"Plan source artifact must not be a symlink: {path}")
+    return store.read_json(run_id, f"artifacts/{name}")
+
+
 class _PipelineRunner:
     def __init__(
         self,
@@ -281,7 +382,22 @@ class _PipelineRunner:
         self.latest_tests: list[dict[str, Any]] = []
         self.latest_triage: dict[str, Any] = {}
 
-    async def run(self, mode: RunMode) -> None:
+    async def run(
+        self,
+        mode: RunMode,
+        *,
+        reused_plan: tuple[dict[str, Any], dict[str, Any]] | None = None,
+        plan_run_id: str | None = None,
+    ) -> None:
+        if reused_plan is not None:
+            orchestration, plan = reused_plan
+            self.store.append_event(
+                self.manifest.run_id,
+                "planning.reused",
+                source_run_id=plan_run_id,
+            )
+            await self._implement_until_approved(orchestration, plan)
+            return
         orchestration = await self._invoke(
             "orchestrator",
             {"request": self.manifest.request, "mode": mode.value},
@@ -290,6 +406,11 @@ class _PipelineRunner:
         )
         plan = await self._plan(orchestration)
         if mode == RunMode.PLAN:
+            self.store.write_json(
+                self.manifest.run_id,
+                "artifacts/approved-orchestration.json",
+                orchestration,
+            )
             self.store.write_json(self.manifest.run_id, "artifacts/approved-plan.json", plan)
             self.store.succeed(self.manifest)
             return

{norn_cli-0.7.1 → norn_cli-0.7.2}/src/norf_harness/resources/skills/norn/SKILL.md

@@ -41,8 +41,14 @@ criteria; do not reduce the request to a vague summary.
 ```bash
 norn plan "<request>" --project <project-root>
 norn run "<request>" --project <project-root>
+norn run "<same-request>" --from-plan <plan-run-id> --project <project-root>
 ```
 
+When the user asks to implement a plan already approved by Norn, use `--from-plan` with that
+successful `plan` run ID and preserve the original request exactly. This starts a new run and
+worktree but reuses the saved orchestration and approved plan instead of invoking those roles
+again. Do not use a plan from another project, a different request, or a non-successful run.
+
 Forward user-specified round limits with `--max-rounds`, `--max-total-rounds`,
 `--max-planner-retries`, or `--max-final-replans`. Never increase a limit after failure without
 the user's approval.

{norn_cli-0.7.1 → norn_cli-0.7.2}/src/norf_harness/resources/skills/norn/references/cli.md

@@ -29,8 +29,14 @@ provider-specific model IDs without consuming model allowance.
 ```bash
 norn plan "<request>" --project <path>
 norn run "<request>" --project <path>
+norn run "<same-request>" --from-plan <plan-run-id> --project <path>
 ```
 
+`--from-plan` skips orchestration, planning, and plan review by reusing the artifacts from a
+successful `plan` run. The project root and request must match the source run exactly. Norn
+validates the source manifest and artifact schemas, records the source run ID, and starts a new
+implementation run in its normal isolated worktree.
+
 Optional per-run limits:
 
 ```text
@@ -94,6 +100,7 @@ Runs are stored under `.norf/runs/<run-id>/` by default:
 manifest.json             authoritative state and selected models
 events.jsonl              append-only lifecycle journal
 artifacts/*.json          role responses, provider attempts, and usage
+artifacts/reused-plan.json copied plan context and source run ID when --from-plan is used
 rounds.json               implementation round history
 findings.json             deduplicated current findings
 test-results.json         local, agent, and E2E results

{norn_cli-0.7.1 → norn_cli-0.7.2}/src/norn_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: norn-cli
-Version: 0.7.1
+Version: 0.7.2
 Summary: Norn: a provider-neutral multi-agent development harness
 License-Expression: Apache-2.0
 Project-URL: Repository, https://github.com/uruca-kk/norn
@@ -70,6 +70,17 @@ assigned evidence directory. The harness rejects missing, stale, symlinked, or
 out-of-directory evidence and archives accepted files under
 `.norf/runs/<run-id>/artifacts/e2e/`.
 
+To implement a previously approved plan without invoking orchestration, planning,
+or plan review again, pass the successful `plan` run ID with the identical request:
+
+```bash
+norn plan "add an audit log"
+norn run "add an audit log" --from-plan <plan-run-id>
+```
+
+Norn verifies the source run mode and status, project root, request text, and saved
+artifact schemas before creating the implementation worktree.
+
 For Codex tester roles, the adapter keeps `workspace-write` filesystem isolation
 and enables command networking through a loopback-only proxy allowlist
 (`localhost` and `127.0.0.1`). Planning and implementation roles retain their
@@ -124,7 +135,7 @@ ruff format --check .
 ruff check .
 python3 -m unittest discover -v
 python3 -m build
-python3 scripts/package_smoke.py dist/norn_cli-0.7.1-py3-none-any.whl
+python3 scripts/package_smoke.py dist/norn_cli-0.7.2-py3-none-any.whl
 ```
 
 CI runs the quality suite on Python 3.12, 3.13, and 3.14, then installs the

{norn_cli-0.7.1 → norn_cli-0.7.2}/tests/test_cli.py

@@ -8,7 +8,7 @@ import tempfile
 import unittest
 from pathlib import Path
 from types import SimpleNamespace
-from unittest.mock import patch
+from unittest.mock import ANY, patch
 
 from norf_harness.cli import main
 from norf_harness.config import load_config
@@ -23,7 +23,7 @@ class CliTests(unittest.TestCase):
             main(["--version"])
 
         self.assertEqual(raised.exception.code, 0)
-        self.assertEqual(output.getvalue().strip(), "norn 0.7.1")
+        self.assertEqual(output.getvalue().strip(), "norn 0.7.2")
 
     def test_init_and_validate(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
@@ -58,7 +58,44 @@ class CliTests(unittest.TestCase):
                 result = main(["run", "build a feature", "--project", str(root)])
 
             self.assertEqual(result, 0)
-            execute.assert_awaited_once()
+            execute.assert_awaited_once_with(
+                ANY,
+                "build a feature",
+                RunMode.RUN,
+                plan_run_id=None,
+            )
+
+    def test_run_forwards_approved_plan_run_id(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            subprocess.run(["git", "init", "-q", str(root)], check=True)
+            outcome = SimpleNamespace(
+                manifest=SimpleNamespace(exit_code=0, run_id="run-2", stop_reason=None),
+                paths=SimpleNamespace(final_report=root / "final-report.md"),
+                exit_code=0,
+            )
+            with (
+                patch.dict(os.environ, {"NORF_HARNESS_USER_CONFIG": str(root / "none")}),
+                patch("norf_harness.cli.execute_pipeline", return_value=outcome) as execute,
+            ):
+                result = main(
+                    [
+                        "run",
+                        "build a feature",
+                        "--from-plan",
+                        "plan-run-1",
+                        "--project",
+                        str(root),
+                    ]
+                )
+
+            self.assertEqual(result, 0)
+            execute.assert_awaited_once_with(
+                ANY,
+                "build a feature",
+                RunMode.RUN,
+                plan_run_id="plan-run-1",
+            )
 
     def test_invalid_round_override_returns_config_error(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:

{norn_cli-0.7.1 → norn_cli-0.7.2}/tests/test_pipeline.py

@@ -222,6 +222,116 @@ class PipelineTests(unittest.TestCase):
             self.assertIn("人間に判断してほしいこと", report)
             self.assertIn("revise", report)
 
+    def test_run_reuses_approved_plan_without_planning_roles(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            config = self.config(root)
+            planning_router = ScriptedRouter(
+                orchestrator=[orchestration()],
+                planner=[plan()],
+                plan_reviewer=[review()],
+            )
+            planned = asyncio.run(
+                execute_pipeline(config, "build a feature", RunMode.PLAN, router=planning_router)
+            )
+            run_router = self.base_router()
+            run_router.responses["orchestrator"].clear()
+            run_router.responses["planner"].clear()
+            run_router.responses["plan_reviewer"].clear()
+
+            outcome = asyncio.run(
+                execute_pipeline(
+                    config,
+                    "build a feature",
+                    RunMode.RUN,
+                    router=run_router,
+                    plan_run_id=planned.manifest.run_id,
+                )
+            )
+
+            self.assertEqual(outcome.exit_code, 0)
+            roles = [call.role for call in run_router.calls]
+            self.assertNotIn("orchestrator", roles)
+            self.assertNotIn("planner", roles)
+            self.assertNotIn("plan_reviewer", roles)
+            self.assertEqual(roles[0], "implementer")
+            self.assertEqual(outcome.manifest.rounds.total, 1)
+            reused = json.loads(
+                (outcome.paths.artifacts / "reused-plan.json").read_text(encoding="utf-8")
+            )
+            self.assertEqual(reused["source_run_id"], planned.manifest.run_id)
+            events = outcome.paths.events.read_text(encoding="utf-8")
+            self.assertIn('"event": "planning.reused"', events)
+
+    def test_run_rejects_reused_plan_for_a_different_request(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            config = self.config(root)
+            planned = asyncio.run(
+                execute_pipeline(
+                    config,
+                    "first request",
+                    RunMode.PLAN,
+                    router=ScriptedRouter(
+                        orchestrator=[orchestration()],
+                        planner=[plan()],
+                        plan_reviewer=[review()],
+                    ),
+                )
+            )
+            run_router = ScriptedRouter()
+
+            outcome = asyncio.run(
+                execute_pipeline(
+                    config,
+                    "different request",
+                    RunMode.RUN,
+                    router=run_router,
+                    plan_run_id=planned.manifest.run_id,
+                )
+            )
+
+            self.assertEqual(outcome.exit_code, 50)
+            self.assertEqual(outcome.manifest.stop_reason, "manual_decision_required")
+            self.assertEqual(run_router.calls, [])
+            self.assertIn("依頼文", outcome.manifest.stop_detail)
+            self.assertTrue(outcome.paths.escalation_report.is_file())
+
+    def test_run_rejects_symlinked_reused_plan_artifact(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            config = self.config(root)
+            planned = asyncio.run(
+                execute_pipeline(
+                    config,
+                    "build a feature",
+                    RunMode.PLAN,
+                    router=ScriptedRouter(
+                        orchestrator=[orchestration()],
+                        planner=[plan()],
+                        plan_reviewer=[review()],
+                    ),
+                )
+            )
+            approved_plan = planned.paths.artifacts / "approved-plan.json"
+            outside = root / "outside-plan.json"
+            approved_plan.replace(outside)
+            approved_plan.symlink_to(outside)
+
+            outcome = asyncio.run(
+                execute_pipeline(
+                    config,
+                    "build a feature",
+                    RunMode.RUN,
+                    router=ScriptedRouter(),
+                    plan_run_id=planned.manifest.run_id,
+                )
+            )
+
+            self.assertEqual(outcome.exit_code, 50)
+            self.assertIn("symlink", outcome.manifest.stop_detail)
+            self.assertTrue(outcome.paths.escalation_report.is_file())
+
     def test_missing_required_e2e_escalates_as_test_infrastructure(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             root = Path(tmp)

{norn_cli-0.7.1 → norn_cli-0.7.2}/tests/test_skill_install.py

@@ -44,6 +44,7 @@ class SkillInstallTests(unittest.TestCase):
         self.assertTrue(
             {"readiness-only", "reviewed-plan", "gated-implementation"}.issubset(case_ids)
         )
+        self.assertIn("approved-plan-implementation", case_ids)
         self.assertTrue({"escalated-run", "interrupted-run"}.issubset(case_ids))
 
     def test_install_all_project_targets_are_explicit_only(self) -> None: