harnessops 0.1.0__py3-none-any.whl

harnessops/__init__.py

@@ -0,0 +1,4 @@
+"""HarnessOps package."""
+
+__version__ = "0.1.0"
+

harnessops/__main__.py

@@ -0,0 +1,5 @@
+from harnessops.cli.main import app
+
+if __name__ == "__main__":
+    app()
+

harnessops/adapters/__init__.py

@@ -0,0 +1,2 @@
+"""Built-in adapters."""
+

harnessops/adapters/base.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class DetectionResult:
+    profile_id: str | None
+    repository_kind: str
+    confidence: float
+    markers: list[str]
+
+
+@dataclass(frozen=True)
+class CheckResult:
+    name: str
+    ok: bool
+    message: str
+
+
+class Adapter:
+    id = "base"
+
+    def detect(self, root: Path) -> DetectionResult:
+        return DetectionResult(None, "unknown", 0.0, [])
+
+    def default_profile_id(self, root: Path) -> str | None:
+        return self.detect(root).profile_id
+
+    def doctor_checks(self, root: Path) -> list[CheckResult]:
+        return []
+
+    def routing_hints(self, text: str) -> list[str]:
+        return []
+
+    def eval_case_templates(self) -> list[str]:
+        return []
+

harnessops/adapters/generic_code.py

@@ -0,0 +1,6 @@
+from harnessops.adapters.base import Adapter
+
+
+class GenericCodeAdapter(Adapter):
+    id = "generic_code"
+

harnessops/adapters/harnessops_core.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from harnessops.adapters.base import Adapter, DetectionResult
+
+
+class HarnessOpsCoreAdapter(Adapter):
+    id = "harnessops_core"
+
+    def detect(self, root: Path) -> DetectionResult:
+        markers = [m for m in ["pyproject.toml", "src/harnessops", "src/harnessops/profiles", "src/harnessops/schemas"] if (root / m).exists()]
+        pyproject = (root / "pyproject.toml").read_text(encoding="utf-8") if (root / "pyproject.toml").exists() else ""
+        if 'name = "harnessops"' in pyproject and len(markers) >= 2:
+            return DetectionResult("harnessops-core", "harnessops-repository", 0.95, markers)
+        return DetectionResult(None, "unknown", 0.0, markers)
+

harnessops/adapters/paper_harness_project.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from harnessops.adapters.base import Adapter, CheckResult, DetectionResult
+
+
+class PaperHarnessProjectAdapter(Adapter):
+    id = "paper_harness_project"
+
+    def detect(self, root: Path) -> DetectionResult:
+        markers = [m for m in ["manuscript", "notes/claim-evidence-map.md", "refs", "submission"] if (root / m).exists()]
+        profile = "paper-harness-project" if len(markers) >= 2 else None
+        return DetectionResult(profile, "project-repository", len(markers) / 4.0, markers)
+
+    def doctor_checks(self, root: Path) -> list[CheckResult]:
+        return [
+            CheckResult("manuscript", (root / "manuscript").exists(), "manuscript exists"),
+            CheckResult("notes", (root / "notes").exists(), "notes exists"),
+        ]
+

harnessops/adapters/paper_harness_upstream.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from harnessops.adapters.base import Adapter, DetectionResult
+
+
+class PaperHarnessUpstreamAdapter(Adapter):
+    id = "paper_harness_upstream"
+
+    def detect(self, root: Path) -> DetectionResult:
+        markers = [m for m in ["template", "scripts/publish-scaffold.sh", "template/manuscript"] if (root / m).exists()]
+        profile = "paper-harness-upstream" if len(markers) >= 2 else None
+        return DetectionResult(profile, "target-repository", len(markers) / 3.0, markers)
+

harnessops/adapters/python_package.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from harnessops.adapters.base import Adapter, DetectionResult
+
+
+class PythonPackageAdapter(Adapter):
+    id = "python_package"
+
+    def detect(self, root: Path) -> DetectionResult:
+        markers = ["pyproject.toml"] if (root / "pyproject.toml").exists() else []
+        return DetectionResult("python-package" if markers else None, "python-package", 0.4, markers)
+

harnessops/adapters/runops_project.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from harnessops.adapters.base import Adapter, CheckResult, DetectionResult
+
+
+class RunopsProjectAdapter(Adapter):
+    id = "runops_project"
+
+    def detect(self, root: Path) -> DetectionResult:
+        markers = [m for m in [".runops/harness.lock", "campaign.toml", "cases", "runs"] if (root / m).exists()]
+        profile = "runops-project" if len(markers) >= 2 else None
+        return DetectionResult(profile, "project-repository", len(markers) / 4.0, markers)
+
+    def doctor_checks(self, root: Path) -> list[CheckResult]:
+        checks = []
+        for marker in ["campaign.toml", "cases", "runs"]:
+            checks.append(CheckResult(marker, (root / marker).exists(), f"{marker} exists"))
+        return checks
+

harnessops/adapters/runops_upstream.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from harnessops.adapters.base import Adapter, DetectionResult
+
+
+class RunopsUpstreamAdapter(Adapter):
+    id = "runops_upstream"
+
+    def detect(self, root: Path) -> DetectionResult:
+        markers = [m for m in ["pyproject.toml", "src/runops", "src/runops/templates"] if (root / m).exists()]
+        pyproject = (root / "pyproject.toml").read_text(encoding="utf-8") if (root / "pyproject.toml").exists() else ""
+        if 'name = "runops"' in pyproject and len(markers) >= 2:
+            return DetectionResult("runops-upstream", "target-repository", 0.95, markers)
+        return DetectionResult(None, "unknown", 0.0, markers)
+

harnessops/cli/__init__.py

@@ -0,0 +1 @@
+"""HarnessOps CLI パッケージ。"""

harnessops/cli/add_failure.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from harnessops.core.paths import find_root
+from harnessops.core.project import load_project
+from harnessops.core.records import create_failure, create_feedback_from_failure, find_record, read_record
+from harnessops.core.render import refresh_views
+from harnessops.core.routing import classify_text
+from harnessops.core.routing import DISPOSITIONS
+
+
+def add_failure_command(
+    title: str = typer.Option(..., "--title"),
+    target: Optional[str] = typer.Option(None, "--target"),
+    context: str = typer.Option("", "--context"),
+    what_happened: str = typer.Option("", "--what-happened"),
+    why_matters: str = typer.Option("", "--why-matters"),
+    desired_behavior: str = typer.Option("", "--desired-behavior"),
+    local_workaround: str = typer.Option("", "--local-workaround"),
+    disposition: Optional[str] = typer.Option(None, "--disposition"),
+    from_file: Optional[str] = typer.Option(None, "--from-file"),
+    interactive: bool = typer.Option(False, "--interactive"),
+) -> None:
+    """プロジェクト側の失敗レコードを作成します。"""
+    del interactive
+    root = find_root()
+    project = load_project(root)
+    if project.overlay_mode not in {"feedback-source", "local-and-feedback"}:
+        typer.echo("add-failure には feedback-source または local-and-feedback mode が必要です")
+        raise typer.Exit(1)
+    file_text = ""
+    if from_file:
+        file_text = (root / from_file).read_text(encoding="utf-8")
+    routing = classify_text(" ".join([title, context, what_happened, file_text]), target=target)
+    if disposition is not None and disposition not in DISPOSITIONS:
+        typer.echo(f"disposition が不正です: {disposition}")
+        raise typer.Exit(1)
+    path = create_failure(
+        project,
+        title=title,
+        target=target,
+        context=context or file_text,
+        what_happened=what_happened or file_text,
+        why_matters=why_matters,
+        desired_behavior=desired_behavior,
+        local_workaround=local_workaround,
+        disposition_type=disposition or routing["type"],
+    )
+    refresh_views(root, project.overlay_path)
+    typer.echo(path.relative_to(root).as_posix())
+
+
+def add_feedback_command(
+    from_id: str = typer.Option(..., "--from"),
+    target: Optional[str] = typer.Option(None, "--target"),
+    feedback_type: Optional[str] = typer.Option(None, "--type"),
+    title: Optional[str] = typer.Option(None, "--title"),
+    summary: str = typer.Option("", "--summary"),
+) -> None:
+    """既存の失敗からフィードバック下書きを作成します。
+
+    下書きは `hops feedback export --sanitize` でエクスポートされるまで非公開です。
+    """
+    root = find_root()
+    project = load_project(root)
+    failure_frontmatter, _ = read_record(find_record(project, from_id))
+    resolved_target = target or failure_frontmatter.get("disposition", {}).get("target") or "harnessops"
+    path = create_feedback_from_failure(
+        project,
+        failure_ref=from_id,
+        target=resolved_target,
+        feedback_type=feedback_type,
+        title=title,
+        summary=summary,
+    )
+    refresh_views(root, project.overlay_path)
+    typer.echo(path.relative_to(root).as_posix())
+
+
+def register(app: typer.Typer) -> None:
+    app.command("add-failure")(add_failure_command)
+    app.command("add-feedback")(add_feedback_command)

harnessops/cli/add_feedback.py

@@ -0,0 +1,4 @@
+from harnessops.cli.add_failure import add_feedback_command
+
+__all__ = ["add_feedback_command"]
+

harnessops/cli/agent.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+import typer
+
+from harnessops.core.agent_bridge import write_bridge
+from harnessops.core.paths import find_root
+
+agent_app = typer.Typer(help="エージェントブリッジ/プラグイン成果物をインストールまたは検証します。")
+
+
+@agent_app.command("bridge")
+def bridge(codex: bool = typer.Option(False, "--codex"), claude: bool = typer.Option(False, "--claude"), force: bool = typer.Option(False, "--force")) -> None:
+    """薄いリポジトリローカルブリッジスキルを生成します。"""
+    if not codex and not claude:
+        codex = True
+    root = find_root()
+    paths = write_bridge(root, codex=codex, claude=claude, force=force)
+    typer.echo(json.dumps([path.relative_to(root).as_posix() for path in paths], indent=2))
+
+
+@agent_app.command("install")
+def install(
+    codex: bool = typer.Option(False, "--codex"),
+    claude: bool = typer.Option(False, "--claude"),
+    scope: str = typer.Option("repo", "--scope"),
+    force: bool = typer.Option(False, "--force"),
+) -> None:
+    """リポジトリローカルブリッジをインストールするか、同梱プラグインをユーザープラグインディレクトリへコピーします。"""
+    if not codex and not claude:
+        codex = True
+    root = find_root()
+    if scope == "repo":
+        bridge(codex=codex, claude=claude, force=force)
+        return
+    if scope != "user":
+        typer.echo("scope は repo または user で指定してください")
+        raise typer.Exit(1)
+    home = Path.home()
+    installed = []
+    for enabled, host, plugin_dir in [
+        (codex, "codex", home / ".codex" / "plugins" / "harnessops"),
+        (claude, "claude", home / ".claude" / "plugins" / "harnessops"),
+    ]:
+        if not enabled:
+            continue
+        source = root / "plugins" / host / "harnessops"
+        if not source.exists():
+            source = Path(__file__).resolve().parents[3] / "plugins" / host / "harnessops"
+        if not source.exists():
+            typer.echo(f"同梱 {host} プラグインソースが見つかりません")
+            raise typer.Exit(1)
+        if plugin_dir.exists():
+            if not force:
+                typer.echo(f"プラグインは既に存在します: {plugin_dir}")
+                raise typer.Exit(2)
+            shutil.rmtree(plugin_dir)
+        plugin_dir.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(source, plugin_dir)
+        installed.append(plugin_dir.as_posix())
+    typer.echo(json.dumps(installed, indent=2))
+
+
+@agent_app.command("verify")
+def verify() -> None:
+    """リポジトリローカルブリッジまたは同梱プラグイン成果物を検証します。"""
+    root = find_root()
+    expected = root / ".agents" / "skills" / "harnessops-bridge" / "SKILL.md"
+    packaged = root / "plugins" / "codex" / "harnessops" / ".codex-plugin" / "plugin.json"
+    if expected.exists() or packaged.exists():
+        typer.echo("ok")
+    else:
+        typer.echo("ブリッジまたは同梱プラグインが見つかりません")
+        raise typer.Exit(1)
+
+
+def register(app: typer.Typer) -> None:
+    app.add_typer(agent_app, name="agent")

harnessops/cli/decide.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import typer
+
+from harnessops.core.paths import find_root
+from harnessops.core.project import load_project
+from harnessops.core.records import create_decision
+
+STATUSES = {"adopted", "rejected", "parked", "needs-more-evidence", "merged-into-other", "not-upstreamable"}
+
+
+def decide_command(
+    experiment: str | None = typer.Option(None, "--experiment"),
+    from_id: str | None = typer.Option(None, "--from"),
+    status: str = typer.Option(..., "--status"),
+    reason: str = typer.Option("", "--reason"),
+    evidence: str = typer.Option("", "--evidence"),
+    regression_risk: str = typer.Option("", "--regression-risk"),
+    follow_up: str = typer.Option("", "--follow-up"),
+    guard_path: str | None = typer.Option(None, "--guard-path"),
+) -> None:
+    """判断レコードを作成します。"""
+    if status not in STATUSES:
+        typer.echo(f"status が不正です: {status}")
+        raise typer.Exit(1)
+    source = experiment or from_id
+    if not source:
+        typer.echo("--experiment または --from を指定してください")
+        raise typer.Exit(1)
+    if status == "adopted" and (not evidence or not regression_risk or not guard_path):
+        typer.echo("adopted の判断には --evidence、--regression-risk、--guard-path が必要です")
+        raise typer.Exit(1)
+    root = find_root()
+    project = load_project(root)
+    path = create_decision(
+        project,
+        source=source,
+        status=status,
+        title=f"{status} {source}",
+        reason=reason or f"`{source}` に対して `{status}` の判断を記録しました。",
+        evidence=evidence or "証拠は指定されていません。この判断は採用可能ではありません。",
+        regression_risk=regression_risk or "回帰リスクは評価されていません。",
+        follow_up=follow_up or "変更を昇格する前にこの判断をレビューしてください。",
+        guard_path=guard_path,
+    )
+    typer.echo(path.relative_to(root).as_posix())
+
+
+def register(app: typer.Typer) -> None:
+    app.command("decide")(decide_command)

harnessops/cli/detect.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from harnessops.core.detect import detect_repository
+
+
+def detect(json_output: bool = typer.Option(False, "--json")) -> None:
+    """リポジトリ種別と推奨プロファイルを推定します。"""
+    root = Path.cwd().resolve()
+    result = detect_repository(root)
+    result["root"] = str(root)
+    if json_output:
+        typer.echo(json.dumps(result, indent=2, sort_keys=True))
+        return
+    typer.echo(f"ルート: {root}")
+    typer.echo(f"プロファイル: {result.get('profile')}")
+    typer.echo(f"リポジトリ種別: {result.get('repository_kind')}")
+    typer.echo(f"検出元: {result.get('source')}")
+    if result.get("markers"):
+        typer.echo("マーカー: " + ", ".join(result["markers"]))
+
+
+def register(app: typer.Typer) -> None:
+    app.command("detect")(detect)

harnessops/cli/doctor.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import json
+
+import typer
+
+from harnessops.core.paths import find_root
+from harnessops.core.project import load_project
+from harnessops.core.validation import doctor as doctor_project
+from harnessops.core.migration import check_migrations
+
+
+def doctor_command(
+    json_output: bool = typer.Option(False, "--json"),
+    provider: bool = typer.Option(False, "--provider"),
+    check_overlay: bool = typer.Option(False, "--check-overlay"),
+    check_records: bool = typer.Option(False, "--check-records"),
+    allow_pending: bool = typer.Option(False, "--allow-pending"),
+) -> None:
+    """HarnessOps リンク、オーバーレイ、プロファイル、レコードを検証します。"""
+    del check_overlay
+    project = load_project(find_root())
+    result = doctor_project(project, check_records=check_records)
+    migration = check_migrations(project)
+    if not migration["ok"] and not allow_pending:
+        result["ok"] = False
+        result["errors"].extend(f"未適用マイグレーション: {item}" for item in migration["pending"])
+    if provider:
+        result["provider"] = {"checked": False, "message": "MVP doctor ではプロバイダコマンド実行は有効化されていません"}
+    if json_output:
+        typer.echo(json.dumps(result, indent=2, sort_keys=True))
+    else:
+        typer.echo("ok" if result["ok"] else "失敗")
+        for warning in result["warnings"]:
+            typer.echo(f"警告: {warning}")
+        for error in result["errors"]:
+            typer.echo(f"エラー: {error}")
+    if not result["ok"]:
+        raise typer.Exit(1)
+
+
+def register(app: typer.Typer) -> None:
+    app.command("doctor")(doctor_command)

harnessops/cli/eval.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import typer
+
+from harnessops.core.evaluation import parse_scores, write_manual_eval
+from harnessops.core.paths import find_root
+from harnessops.core.project import load_project
+from harnessops.core.records import find_record, read_record
+
+
+def eval_command(
+    case: str | None = typer.Option(None, "--case"),
+    manual: bool = typer.Option(False, "--manual"),
+    all_cases: bool = typer.Option(False, "--all"),
+    experiment: str | None = typer.Option(None, "--experiment"),
+    score: list[str] = typer.Option(None, "--score"),
+    notes: str = typer.Option("", "--notes"),
+) -> None:
+    """評価ケースの多軸手動スコアカードを保存します。"""
+    root = find_root()
+    project = load_project(root)
+    cases = []
+    if all_cases:
+        cases = [path.stem.split("-", 1)[0] for path in sorted((project.overlay_dir / "records/eval-cases").glob("E*.md"))]
+    elif experiment:
+        try:
+            experiment_path = find_record(project, experiment)
+            frontmatter, _ = read_record(experiment_path)
+            cases = [str(item) for item in frontmatter.get("eval_cases", [])]
+        except FileNotFoundError:
+            typer.echo(f"experiment が見つかりません: {experiment}")
+            raise typer.Exit(1)
+    elif case:
+        cases = [case]
+    else:
+        typer.echo("--case または --all を指定してください")
+        raise typer.Exit(1)
+    if not cases:
+        typer.echo("評価ケースが見つかりません")
+        raise typer.Exit(1)
+    if not manual:
+        typer.echo("このコマンドには手動採点が必要です。--manual を指定してください")
+        raise typer.Exit(1)
+    try:
+        scores = parse_scores(score or [])
+    except ValueError as exc:
+        typer.echo(str(exc))
+        raise typer.Exit(1) from exc
+    outputs = []
+    for case_id in cases:
+        yml_path, md_path = write_manual_eval(project, case_id=case_id, scores=scores, notes=notes, experiment=experiment)
+        outputs.append(yml_path.relative_to(root).as_posix())
+        outputs.append(md_path.relative_to(root).as_posix())
+    typer.echo("\n".join(outputs))
+
+
+def register(app: typer.Typer) -> None:
+    app.command("eval")(eval_command)

harnessops/cli/feedback.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from harnessops.core.paths import find_root
+from harnessops.core.project import load_project
+from harnessops.core.records import create_imported_feedback, next_id, read_record
+from harnessops.core.render import refresh_views
+from harnessops.core.sanitize import sanitize_text
+from harnessops.profiles.registry import load_profile
+
+feedback_app = typer.Typer(help="フィードバックバンドルをエクスポート/インポートします。")
+
+
+@feedback_app.command("export")
+def export_feedback(
+    target: Optional[str] = typer.Option(None, "--target"),
+    sanitize: bool = typer.Option(False, "--sanitize"),
+    format: str = typer.Option("markdown", "--format"),  # noqa: A002
+    allow_private: bool = typer.Option(False, "--allow-private"),
+) -> None:
+    """プロジェクト側レコードからサニタイズ済み上流/メタフィードバックバンドルを生成します。"""
+    root = find_root()
+    project = load_project(root)
+    if not sanitize and not allow_private:
+        typer.echo("--allow-private なしの未サニタイズエクスポートは拒否します")
+        raise typer.Exit(1)
+    profile = load_profile(project.profile_id)
+    records = []
+    target_filter = target or "all"
+    for path in sorted((project.overlay_dir / "records/failures").glob("*.md")):
+        frontmatter, body = read_record(path)
+        disposition = frontmatter.get("disposition", {})
+        if disposition.get("type") not in {"target-upstream-candidate", "meta-harness-candidate", "protocol-candidate"}:
+            continue
+        if disposition.get("target") == target_filter or target_filter == "all":
+            records.append((path, frontmatter, body))
+    for rel in ["records/upstream-feedback", "records/meta-feedback"]:
+        for path in sorted((project.overlay_dir / rel).glob("*.md")):
+            frontmatter, body = read_record(path)
+            if frontmatter.get("target") == target_filter or target_filter == "all":
+                records.append((path, frontmatter, body))
+    if not records:
+        typer.echo("一致するフィードバックレコードがありません")
+        raise typer.Exit(1)
+    resolved_targets = sorted({str(record[1].get("target") or record[1].get("disposition", {}).get("target") or "unknown") for record in records})
+    export_target = target or ("mixed" if len(resolved_targets) != 1 else resolved_targets[0])
+    prefix = "MF" if export_target == "harnessops" else "UF"
+    out_dir = project.overlay_dir / "views" / "exported-feedback"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    export_id = next_id(out_dir, prefix)
+    title = f"{export_target} へのフィードバック"
+    sections = []
+    for path, frontmatter, body in records:
+        sections.append(f"## 送信元 {frontmatter.get('id')}: {path.name}\n\n{body.strip()}\n")
+    bundle_body = "\n".join(sections)
+    if sanitize:
+        bundle_body = sanitize_text(bundle_body, root=root, profile=profile, allow_private=allow_private)
+    if format in {"issue", "github-issue"}:
+        bundle_body = "## Issue下書き\n\n" + bundle_body + "\n\n## 確認\n\nこれは下書きのみです。HarnessOps はリモートIssueを自動作成しません。\n"
+    frontmatter = {
+        "id": export_id,
+        "record_type": "meta_feedback" if prefix == "MF" else "upstream_feedback",
+        "created_at": records[0][1].get("created_at"),
+        "status": "draft",
+        "target": export_target,
+        "source_failure": records[0][1].get("id"),
+        "sanitized": bool(sanitize),
+        "visibility": "sanitized" if sanitize else "private-until-sanitized",
+        "format": format,
+        "included_targets": resolved_targets,
+    }
+    text = "---\n" + json.dumps(frontmatter, indent=2) + "\n---\n\n# " + title + "\n\n" + bundle_body
+    out_path = out_dir / f"{export_id}-{export_target}-feedback.md"
+    out_path.write_text(text, encoding="utf-8")
+    refresh_views(root, project.overlay_path)
+    typer.echo(out_path.relative_to(root).as_posix())
+
+
+@feedback_app.command("import")
+def import_feedback(
+    path: Optional[Path] = typer.Argument(None),
+    issue: Optional[int] = typer.Option(None, "--issue"),
+    repo: Optional[str] = typer.Option(None, "--repo"),
+) -> None:
+    """フィードバックバンドルをターゲット側 harness-lab にインポートします。"""
+    root = find_root()
+    project = load_project(root)
+    if project.overlay_mode not in {"upstream-lab", "meta-lab"}:
+        typer.echo("feedback import には upstream-lab または meta-lab mode が必要です")
+        raise typer.Exit(1)
+    if issue is not None:
+        source = {"id": f"ISSUE-{issue}", "record_type": "upstream_feedback", "issue": {"url": f"https://github.com/{repo or 'unknown'}/issues/{issue}"}}
+        body = f"{repo or 'unknown'} から GitHub issue {issue} をインポートしました。"
+        title = f"GitHub issue {issue}"
+    elif path is not None:
+        source_path = path if path.is_absolute() else root / path
+        source, body = read_record(source_path)
+        if source.get("record_type") not in {"upstream_feedback", "meta_feedback"} or not source.get("sanitized", False):
+            typer.echo("import にはサニタイズ済み upstream_feedback または meta_feedback バンドルが必要です")
+            raise typer.Exit(1)
+        title = source_path.stem
+    else:
+        typer.echo("バンドルパスまたは --issue を指定してください")
+        raise typer.Exit(1)
+    out_path = create_imported_feedback(project, source_record=source, body=body, title=title)
+    refresh_views(root, project.overlay_path)
+    typer.echo(out_path.relative_to(root).as_posix())
+
+
+def register(app: typer.Typer) -> None:
+    app.add_typer(feedback_app, name="feedback")