okstra 0.163.2 → 0.165.0

package/runtime/python/okstra_ctl/issue_signals.py

@@ -1,186 +0,0 @@
-"""이슈 판정 신호 — 원본(익명화 전) 레코드에서만 계산되는 순수 함수.
-
-익명화는 message/stderrExcerpt/command 의 경로를 <path> 로 붕괴시키므로
-(error_zip._PATHISH), 경로 기반 신호는 익명화 뒤에는 계산할 수 없다.
-신호 값 자체는 불리언·카운트라 공개 이슈에 실어도 안전하다.
-"""
-from __future__ import annotations
-
-OKSTRA_DEFECT = "okstra-defect"
-ENVIRONMENT_POLICY = "environment-policy"
-TARGET_CODE = "target-code"
-
-# okstra-defect 판정에 필요한 강한 지지 신호 수. 한 신호만으로는 공개 이슈를
-# 만들지 않는다.
-MIN_SUPPORTING_SIGNALS = 2
-
-# 단일 phase 클러스터면 무조건 켜지므로 판정을 지탱하지 못한다. 근거로 보고하되
-# 최소 근거 수에는 세지 않는다 — 세면 "근거 2개"가 "진짜 근거 1개 + 공짜 한 자리"가 된다.
-WEAK_SIGNALS = ("phaseLock",)
-
-# 리드가 규칙 위반을 관측한 지점에서 찍는 값이라(prompts/lead/okstra-lead-contract.md)
-# 워커 자기신고와 성격이 다르고, 그 자체로 okstra 배선 문제를 가리킨다. 확산이 없어도
-# — 한 프로젝트·한 태스크 안에서만 반복돼도 — 최소 근거 수를 우회한다.
-SELF_SUFFICIENT_SIGNALS = ("contractViolation",)
-
-SIGNAL_SUPPORT = {
-    "contractViolation": OKSTRA_DEFECT,
-    "okstraOwnedPath": OKSTRA_DEFECT,
-    "invariantViolated": OKSTRA_DEFECT,
-    "taskSpread": OKSTRA_DEFECT,
-    "projectSpread": OKSTRA_DEFECT,
-    "agentSpread": OKSTRA_DEFECT,
-    "phaseLock": OKSTRA_DEFECT,
-    "declaredCause": ENVIRONMENT_POLICY,
-    "targetSourcePath": TARGET_CODE,
-}
-
-# okstra 가 소유한 표면. 여기서 난 실패는 타겟 코드가 아니라 okstra 배선 문제다.
-# 태스크 워크트리(~/.okstra/worktrees/...)는 제외한다 — 그 디렉터리는 타겟 저장소의
-# 체크아웃이라 거기서 난 실패는 남의 코드에서 난 것이다.
-_OKSTRA_PATH_MARKERS = (
-    "/.okstra/tasks/", "/.okstra/runs/", "/.okstra/decisions/",
-    "/.okstra/project.json", "/.okstra/glossary.md",
-    "/.okstra/recent.jsonl", "/.okstra/active.jsonl", "/.okstra/bin/",
-    "okstra_ctl", "scripts/okstra-",
-)
-# 환경 정책 사안으로 미리 분류된 cause. sandbox-denied 는 실측상 오진이 많아
-# 여기 넣지 않는다 — 프로브 증거 검사는 error_issue.validate_candidate 가 맡는다.
-_ENVIRONMENT_CAUSES = ("auth-failed", "service-unavailable")
-
-_FREETEXT_FIELDS = ("message", "stderrExcerpt", "command")
-
-# 경로 신호가 어느 필드를 읽었는지 알리는 라벨. 이 문자열은 공개 이슈 본문의
-# source 열에 그대로 실리므로 error_issue 의 유출 허용목록이 같은 값을 참조한다 —
-# 여기서 필드가 늘면 라벨과 허용목록이 함께 따라간다.
-FREETEXT_SOURCE = "/".join(_FREETEXT_FIELDS)
-
-
-def _freetext(rec: dict) -> str:
-    """자유 텍스트 필드를 잇되 프로젝트 루트 접두는 지우고 본다.
-
-    `message`·`stderrExcerpt`·`command` 에는 타겟의 절대 프로젝트 루트가 통째로
-    박혀 있다. 루트 경로 자체에 `app/`·`lib/` 같은 조각이 들어 있으면 실패가
-    어디서 났든 `targetSourcePath` 가 켜진다 — 실측에서 `okstraOwnedPath` 가
-    켜진 103개 클러스터 중 86개가 `targetSourcePath` 도 함께 켰고, 그중 83개는
-    사용자의 프로젝트가 `.../FontsNinja/app/` 아래 있다는 이유뿐이었다.
-
-    루트를 지운 텍스트로 계산하면 31개 클러스터의 판정·반대신호가 달라진다.
-    반대 신호는 후보를 `skip` 으로 떨어뜨리므로 이 오발화는 본문 잡음이 아니라
-    진짜 결함을 조용히 묻는다 — 실측 7건의 반대신호 후보 중 4건이 깨끗해지고
-    그중 하나는 `contract-violation` 이다."""
-    root = str(rec.get("_projectRoot", "") or "")
-    parts = []
-    for field in _FREETEXT_FIELDS:
-        value = str(rec.get(field, "") or "")
-        parts.append(value.replace(root, "") if root else value)
-    return " ".join(parts)
-
-
-def _has_okstra_path(rec: dict) -> bool:
-    text = _freetext(rec)
-    return any(marker in text for marker in _OKSTRA_PATH_MARKERS)
-
-
-def _has_target_path(rec: dict) -> bool:
-    """okstra 경로가 함께 잡혀도 단락하지 않는다 — 둘 다 켜두면 모순이
-    conflicting 으로 드러나 사람이 판단할 수 있다. 단락시키면 반대 근거가
-    아예 사라진다."""
-    text = _freetext(rec)
-    return any(seg in text for seg in ("src/", "lib/", "app/", "tests/"))
-
-
-def _distinct(records: list[dict], field: str) -> int:
-    return len({str(r.get(field, "")) for r in records if r.get(field)})
-
-
-def _signal(name: str, value, source: str) -> dict:
-    return {"signal": name, "value": value, "source": source}
-
-
-def compute_signals(records: list[dict]) -> list[dict]:
-    """한 클러스터의 원본 레코드에서 신호를 계산한다."""
-    if not records:
-        return []
-    phases = {str(r.get("phase", "")) for r in records if r.get("phase")}
-    causes = [
-        str(r.get("context", {}).get("cause", ""))
-        for r in records
-        if isinstance(r.get("context"), dict) and r.get("context", {}).get("cause")
-    ]
-    # cause 는 워커가 스스로 적는 값이라, 1건짜리 자기신고가 클러스터 전체를
-    # 환경 사안으로 돌리지 못하게 과반을 요구한다. sandbox-denied 를 아예 뺀 것과
-    # 같은 불신을 나머지 cause 에도 건다.
-    declared = [c for c in causes if c in _ENVIRONMENT_CAUSES]
-    environment_cause = ""
-    if declared:
-        top = max(sorted(set(declared)), key=declared.count)
-        if declared.count(top) * 2 > len(records):
-            environment_cause = top
-    return [
-        _signal("contractViolation",
-                any(r.get("errorType") == "contract-violation" for r in records),
-                "errorType"),
-        _signal("okstraOwnedPath",
-                any(_has_okstra_path(r) for r in records),
-                FREETEXT_SOURCE),
-        _signal("targetSourcePath",
-                any(_has_target_path(r) for r in records),
-                FREETEXT_SOURCE),
-        _signal("taskSpread", _distinct(records, "taskKey"), "taskKey"),
-        _signal("projectSpread", _distinct(records, "_projectRoot"), "_projectRoot"),
-        _signal("agentSpread", _distinct(records, "agent"), "agent"),
-        _signal("phaseLock", len(phases) == 1, "phase"),
-        _signal("declaredCause", environment_cause, "context.cause"),
-    ]
-
-
-def signal_fires(sig: dict) -> bool:
-    """신호가 켜졌는지. 카운트형은 2 이상일 때만 확산 신호로 인정한다.
-
-    공개 함수다 — 등록 직전 게이트(error_issue.validate_candidate)가 같은 판단을
-    다시 걸어야 하는데, 비공개로 두면 그쪽이 자기 판본을 새로 만들면서
-    `taskSpread: 1` 같은 꺼진 신호를 근거로 세는 더 약한 규칙이 된다.
-
-    `value` 가 없는 항목은 꺼진 것으로 본다. 이 함수는 사람이 손으로 고친
-    plan.json 을 읽는 자리에 있어, 필드 하나가 빠졌다고 KeyError 로 터지면
-    등록 루프가 그 자리에서 끊긴다 — 앞의 후보는 이미 올라간 뒤다."""
-    value = sig.get("value")
-    if sig["signal"] in ("taskSpread", "projectSpread", "agentSpread"):
-        return isinstance(value, int) and value >= 2
-    if isinstance(value, bool):
-        return value
-    return bool(value)
-
-
-def classify(signals: list[dict]) -> tuple[str, list[dict], list[dict]]:
-    """(분류, 지지 신호, 반대 신호) 를 돌려준다.
-
-    declaredCause 가 켜지면 환경 정책이 이긴다 — 워커가 명시적으로 분류한
-    사안을 신호 개수로 뒤집지 않는다. 그 외에는 최다 지지 분류를 고르고,
-    다른 분류를 지지하는 신호는 반대 신호로 그대로 노출한다."""
-    fired = [s for s in signals if signal_fires(s)]
-    by_class: dict[str, list[dict]] = {}
-    for sig in fired:
-        by_class.setdefault(SIGNAL_SUPPORT[sig["signal"]], []).append(sig)
-
-    if by_class.get(ENVIRONMENT_POLICY):
-        verdict = ENVIRONMENT_POLICY
-    elif not by_class:
-        verdict = ""
-    else:
-        verdict = max(by_class.items(), key=lambda kv: (len(kv[1]), kv[0]))[0]
-
-    supporting = by_class.get(verdict, [])
-    # okstra-defect 만 공개 이슈가 되므로 그 판정에만 최소 근거 수를 요구하고,
-    # 약한 신호는 세지 않는다. 다른 분류는 후보에서 빠지는 방향이라 근거 하나로도
-    # 해가 없다. supporting 에는 약한 신호도 그대로 담아 이슈 본문에 남긴다.
-    if verdict == OKSTRA_DEFECT:
-        strong = [s for s in supporting if s["signal"] not in WEAK_SIGNALS]
-        alone_is_enough = any(
-            s["signal"] in SELF_SUFFICIENT_SIGNALS for s in strong)
-        if not alone_is_enough and len(strong) < MIN_SUPPORTING_SIGNALS:
-            return "", [], []
-
-    conflicting = [s for s in fired if SIGNAL_SUPPORT[s["signal"]] != verdict]
-    return verdict, supporting, conflicting

package/runtime/python/okstra_ctl/lead_runtime.py

@@ -1,115 +0,0 @@
-"""Lead runtime metadata shared by render and prepare paths."""
-from __future__ import annotations
-
-from dataclasses import dataclass, replace
-
-
-@dataclass(frozen=True)
-class LeadRuntimeInfo:
-    runtime: str
-    agent: str
-    agent_label: str
-    role: str
-    adapter_name: str
-    adapter_dispatch_mode: str
-    session_accounting: str
-    has_claude_session: bool
-    adapter_contract_relative_path: str
-
-    def adapter_payload(self) -> dict[str, str]:
-        return {
-            "name": self.adapter_name,
-            "dispatchMode": self.adapter_dispatch_mode,
-            "sessionAccounting": self.session_accounting,
-        }
-
-
-ARTIFACT_ONLY_LEAD_RUNTIMES = frozenset({"codex", "antigravity", "external"})
-
-# Not a lead runtime — an adapter selected by the environment, so it is absent
-# from ALLOWED_LEAD_RUNTIMES and from _LEAD_RUNTIMES on purpose. `--lead-runtime
-# cmux` is not a thing a user can ask for; see `with_cmux_dispatch`.
-CMUX_ADAPTER_NAME = "cmux"
-CMUX_ADAPTER_RELATIVE_PATH = "lead/adapters/cmux.md"
-
-_LEAD_RUNTIMES = {
-    "claude-code": LeadRuntimeInfo(
-        runtime="claude-code",
-        agent="claude",
-        agent_label="Claude Code",
-        role="Claude lead",
-        adapter_name="claude-code",
-        adapter_dispatch_mode="team",
-        session_accounting="claude-jsonl",
-        has_claude_session=True,
-        adapter_contract_relative_path="lead/adapters/claude-code.md",
-    ),
-    "codex": LeadRuntimeInfo(
-        runtime="codex",
-        agent="codex",
-        agent_label="Codex CLI",
-        role="Codex lead",
-        adapter_name="codex",
-        adapter_dispatch_mode="render-only",
-        session_accounting="artifact-only",
-        has_claude_session=False,
-        adapter_contract_relative_path="lead/adapters/codex.md",
-    ),
-    "antigravity": LeadRuntimeInfo(
-        runtime="antigravity",
-        agent="antigravity",
-        agent_label="Antigravity CLI",
-        role="Antigravity lead",
-        adapter_name="antigravity",
-        adapter_dispatch_mode="render-only",
-        session_accounting="artifact-only",
-        has_claude_session=False,
-        adapter_contract_relative_path="lead/adapters/antigravity.md",
-    ),
-    "external": LeadRuntimeInfo(
-        runtime="external",
-        agent="external",
-        agent_label="External harness",
-        role="Okstra lead",
-        adapter_name="external",
-        adapter_dispatch_mode="render-only",
-        session_accounting="artifact-only",
-        has_claude_session=False,
-        adapter_contract_relative_path="lead/adapters/external.md",
-    ),
-}
-
-
-# Derived rather than restated: a hand-written copy of the registry's own keys
-# is a list that can disagree with the thing it describes.
-ALLOWED_LEAD_RUNTIMES = tuple(_LEAD_RUNTIMES)
-
-
-def lead_runtime_info(runtime: str) -> LeadRuntimeInfo:
-    try:
-        return _LEAD_RUNTIMES[runtime]
-    except KeyError as exc:
-        allowed = ", ".join(ALLOWED_LEAD_RUNTIMES)
-        raise ValueError(f"unsupported lead runtime: {runtime} (allowed: {allowed})") from exc
-
-
-def is_artifact_only_runtime(runtime: str) -> bool:
-    return runtime in ARTIFACT_ONLY_LEAD_RUNTIMES
-
-
-def with_cmux_dispatch(info: LeadRuntimeInfo) -> LeadRuntimeInfo:
-    """The same lead, minus the two fields cmux takes over.
-
-    On the cmux path okstra owns the worker panes rather than the host, so
-    "which adapter" and "does this lead dispatch or only render" stop depending
-    on who the lead is — they are the same for every runtime. Overriding the two
-    fields keeps that answer in one adapter file rather than repeating it in
-    four. Everything else (agent, label, role, session accounting) still
-    describes the lead itself and is left untouched.
-    """
-    return replace(
-        info,
-        adapter_name=CMUX_ADAPTER_NAME,
-        adapter_dispatch_mode="team",
-        adapter_contract_relative_path=CMUX_ADAPTER_RELATIVE_PATH,
-    )

package/runtime/python/okstra_ctl/runner_resolution.py

@@ -1,103 +0,0 @@
-"""Resolve native versus CLI execution from host and provider capabilities."""
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from .models import (
-    UnknownProviderError,
-    provider_spec,
-    provider_supports_role,
-    provider_wrappers,
-)
-
-NATIVE_SESSION = "native-session"
-CLI_WRAPPER = "cli-wrapper"
-RUNNER_VALUES = frozenset({NATIVE_SESSION, CLI_WRAPPER})
-
-_HOST_NATIVE_PROVIDERS = {
-    "claude-code": frozenset({"claude"}),
-    "codex": frozenset({"codex"}),
-    "antigravity": frozenset({"antigravity"}),
-    "external": frozenset(),
-}
-
-
-def native_provider_for_host(host_runtime: str) -> str:
-    """Return the single provider owned by an in-session host, if any."""
-    providers = _HOST_NATIVE_PROVIDERS.get(host_runtime)
-    if providers is None:
-        allowed = ", ".join(_HOST_NATIVE_PROVIDERS)
-        raise RunnerResolutionError(
-            f"unknown host runtime {host_runtime!r}. Allowed values: {allowed}"
-        )
-    return next(iter(providers), "")
-
-
-class RunnerResolutionError(ValueError):
-    """Raised when an assignment cannot run on the selected host."""
-
-
-@dataclass(frozen=True)
-class RunnerResolution:
-    runner: str
-    wrapper: str
-    reason: str
-
-
-def resolve_runner(
-    host_runtime: str,
-    provider: str,
-    role: str,
-    requested_runner: str = "",
-) -> RunnerResolution:
-    """Resolve an assignment without inferring the host from installed CLIs."""
-    native_providers = _HOST_NATIVE_PROVIDERS.get(host_runtime)
-    if native_providers is None:
-        allowed = ", ".join(_HOST_NATIVE_PROVIDERS)
-        raise RunnerResolutionError(
-            f"unknown host runtime {host_runtime!r}. Allowed values: {allowed}"
-        )
-    try:
-        spec = provider_spec(provider)
-    except UnknownProviderError as exc:
-        raise RunnerResolutionError(str(exc)) from exc
-    if not provider_supports_role(provider, role):
-        raise RunnerResolutionError(
-            f"provider {provider!r} does not support role {role!r}"
-        )
-    requested = (requested_runner or "").strip()
-    if requested and requested not in RUNNER_VALUES:
-        allowed = ", ".join(sorted(RUNNER_VALUES))
-        raise RunnerResolutionError(
-            f"unknown runner {requested!r}. Allowed values: {allowed}"
-        )
-    if requested == NATIVE_SESSION and provider not in native_providers:
-        raise RunnerResolutionError(
-            f"host runtime {host_runtime!r} does not provide native {provider!r} execution"
-        )
-    if requested == NATIVE_SESSION or (not requested and provider in native_providers):
-        return RunnerResolution(
-            runner=NATIVE_SESSION,
-            wrapper="",
-            reason=f"{host_runtime} provides native {provider} execution",
-        )
-    if not spec.wrapper:
-        raise RunnerResolutionError(
-            f"provider {provider!r} has no CLI wrapper for role {role!r}"
-        )
-    return RunnerResolution(
-        runner=CLI_WRAPPER,
-        wrapper=spec.wrapper,
-        reason=f"{host_runtime} uses the registered {provider} CLI wrapper",
-    )
-
-
-def worker_wrapper_registry(report_writer_provider: str = "claude") -> dict[str, str]:
-    """Worker-id wrapper map for dispatch front ends."""
-    wrappers = provider_wrappers("analyser")
-    report_writer = provider_spec(report_writer_provider)
-    if not provider_supports_role(report_writer_provider, "report-writer"):
-        raise RunnerResolutionError(
-            f"provider {report_writer_provider!r} does not support report-writer"
-        )
-    return {**wrappers, "report-writer": report_writer.wrapper}

package/runtime/skills/okstra-inspect/facets/error-issue.md

@@ -1,77 +0,0 @@
-# okstra-inspect facet — error-issue
-
-Loaded lazily by the dispatch table in `SKILL.md` (core). Shared rules — Step 0 preflight, the standard task-key resolution rule (0/1/N), the no-task fallback, and Output Rules — live in the core file and still apply here.
-
-## error-issue
-
-Trigger phrases: "okstra error-issue", "issue candidates", "file okstra issues", "report okstra defects".
-
-Turn okstra run anomalies into GitHub issue candidates, then file the approved ones. Read-only over every target's `.okstra/`. Apart from the plan file you edit between the two commands, the only write is the GitHub issue — and that only after the user approves.
-
-**Never run `submit` without an explicit user approval in this session.** `plan` is free to run unattended; `submit` is not.
-
-### error-issue.1 — Build the plan
-
-```bash
-okstra error-issue plan --out ~/.okstra/error-issue-plan.json
-```
-
-Parse the stdout JSON: `candidateCount`, `belowGate`, `notOkstraDefect`, `conflicted`, `unreachableRuns`.
-
-`candidateCount` includes candidates whose action is already `skip`, so it is not the number of issues that will be filed. Report the filed count from the create/comment rows of the board below.
-
-### error-issue.2 — Review each candidate's classification
-
-Read the plan file. For each candidate, verify the recorded `classification` against its `signals` list. The classification was computed by `issue_signals.classify`; your job is to confirm it reads correctly against the raw evidence, not to invent a new one.
-
-If a candidate's signals do not support its classification, drop it from the plan file rather than arguing with it in prose. If deciding requires reading the raw `stderrExcerpt`, add an evidence entry and quote the line — an evidence entry always carries all three of `signal`, `value`, `source`, so write `{"signal": "<the signal it backs>", "value": "<the quoted line>", "source": "message excerpt"}`. `submit` rejects an entry missing any of the three; a two-key entry is not a lighter form of evidence, it is an unreadable one.
-
-### error-issue.3 — Present the approval board (Korean)
-
-First state the destination on its own line — `plan.json` 의 `repo` 값을 그대로 읽어 `등록 대상: <repo>` 로 적는다. 이 값은 `~/.okstra/error-issue.json` 이 덮어쓸 수 있으므로 okstra 레포라고 단정하지 않는다. CLI 가 `repo` 없는 plan 을 거부하는 이유가 바로 이것 — 목적지는 승인 화면에 반드시 있어야 할 값이다.
-
-Then show two tables, never merged into one.
-
-**등록 예정** — candidates whose action is `create` or `comment`. `title` 열은 실제로 올라갈 제목 그대로 싣는다. 그것이 없으면 "승인 화면에서 본 것과 올라가는 것이 같다"가 성립하지 않는다:
-
-| # | action | title | fingerprint | errorType / phase | 발생 | 지지 신호(`evidence`) | 기존 이슈 |
-|---|---|---|---|---|---:|---|---|
-
-**보류** — candidates whose action is already `skip`. They are NOT filed; they are shown so the human sees what was set aside. `skip` has two distinct origins and the row must say which:
-
-- **반대 신호** — `conflictingSignals` is non-empty. `classify` called it an okstra defect while another signal pointed elsewhere.
-- **이미 보고됨** — `conflictingSignals` is empty and `existingIssue` is set. An open issue already covers the last occurrence, so there is nothing new to say.
-
-| # | fingerprint | errorType / phase | 발생 | 보류 사유 | 지지 신호 | 반대 신호 / 기존 이슈 |
-|---|---|---|---:|---|---|---|
-
-**본문** — then, for every `등록 예정` row, print that candidate's `body` **whole and verbatim** in a fenced block, one block per row, labelled with the same `#`. Never elide a section. The table summarizes; the body is what actually gets posted, and "승인 화면에서 본 것과 올라가는 것이 같다" is this facet's whole claim — a title plus a signal list does not carry it.
-
-Bodies are bounded by construction: every line is derived (counts, signal values, invariant names) except the one representative message, which shares its source with the `title` in the same row. The raw error records are deliberately NOT in the body — their free text carries the reporting project's ticket ids and source filenames, and no shape rule can separate those from okstra's own vocabulary. They stay in the candidate's `records` in `plan.json` and in the `okstra error-zip` archive. If you need to vet them, read `plan.json` locally; do not paste them into the body.
-
-Then ask via `AskUserQuestion` (options: 전부 등록 / 일부만 선택 / 등록 안 함). Deselected candidates are removed from the plan file before submit.
-
-A held candidate is promoted only when the user explicitly says so, and the action you set depends on `existingIssue`:
-
-- `existingIssue` is null → set `action` to `create`.
-- `existingIssue` is set → set `action` to `comment`. **Never `create` over an existing issue** — that files a duplicate carrying the same `okstra-fingerprint` marker, and from then on `find_existing_issue` matches whichever of the two the list returns first, so every later run reports against an arbitrary one.
-
-Say which you set and why.
-
-Surface `unreachableRuns > 0` — no silent omission.
-
-### error-issue.4 — Submit
-
-Only after an explicit approval:
-
-```bash
-okstra error-issue submit --plan ~/.okstra/error-issue-plan.json
-```
-
-Report `created` / `commented` / `skipped` / `rejected` / `failed`. If `rejected > 0`, print each rejection's `reasons` verbatim — a rejection means the outbound text or the evidence failed the final gate, and it is never something to work around.
-
-If `failed > 0`, print each failure's `error` and **do not re-run `submit` on the same plan file**. A failure is a candidate that crashed or whose `gh` call errored; the candidates before it were already filed, and their `action` in the plan file still says `create`. Re-run `error-issue plan` instead — the fingerprint lookup turns the already-filed ones into `comment`/`skip`, which is the only thing that keeps a retry from filing duplicates.
-
-### error-issue.5 — Next step
-
-End with: "이 이슈를 실제로 고치려면 `/okstra-brief-gen` 에 이슈 URL 을 주고, okstra 레포에서 `okstra-run --task-type error-analysis` 로 진행하세요."

package/src/commands/inspect/error-issue.mjs

@@ -1,27 +0,0 @@
-import { runPythonModule } from "../../lib/python-helper.mjs";
-
-const USAGE = `okstra error-issue — turn okstra run anomalies into GitHub issue candidates
-
-Usage:
-  okstra error-issue plan --out <path>
-  okstra error-issue submit --plan <path>
-
-'plan' walks the global run-index, gates clusters by occurrence and recency,
-computes classification signals from the raw records, checks GitHub for an
-existing issue carrying the same fingerprint, and writes plan.json.
-'submit' reads that file only, re-validates every candidate, and files or
-comments via gh. A candidate that fails validation is never sent.
-`;
-
-export async function run(args) {
-  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
-    process.stdout.write(USAGE);
-    return 0;
-  }
-  const result = await runPythonModule({
-    module: "okstra_ctl.error_issue",
-    args,
-    stdio: "inherit-stdout",
-  });
-  return result.code;
-}

package/src/lib/runtime-readiness.mjs

@@ -1,90 +0,0 @@
-import { promises as fs } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-
-const WORKSPACE_TRUST_CHECK_ID = "workspace-trust";
-
-function ready(runtime, check) {
-  return { runtime, status: "ready", checks: check ? [check] : [] };
-}
-
-function blocked(runtime) {
-  return {
-    runtime,
-    status: "blocked",
-    checks: [{
-      id: WORKSPACE_TRUST_CHECK_ID,
-      status: "required",
-      action: "restart-and-trust",
-    }],
-  };
-}
-
-function unknown(runtime) {
-  return {
-    runtime,
-    status: "unknown",
-    checks: [{
-      id: WORKSPACE_TRUST_CHECK_ID,
-      status: "unavailable",
-      action: "open-project-and-trust",
-    }],
-  };
-}
-
-function isJsonObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-async function hasProjectSettings(projectRoot) {
-  try {
-    await fs.lstat(join(projectRoot, ".claude", "settings.local.json"));
-    return true;
-  } catch (error) {
-    if (error?.code === "ENOENT") return false;
-    throw error;
-  }
-}
-
-async function checkClaudeCodeReadiness({ projectRoot, homeDir }) {
-  const runtime = "claude-code";
-  try {
-    if (!(await hasProjectSettings(projectRoot))) {
-      return ready(runtime, {
-        id: WORKSPACE_TRUST_CHECK_ID,
-        status: "not-applicable",
-      });
-    }
-
-    const rawState = await fs.readFile(join(homeDir, ".claude.json"), "utf8");
-    const state = JSON.parse(rawState);
-    if (!isJsonObject(state?.projects)) return unknown(runtime);
-
-    const projectState = state.projects[resolve(projectRoot)];
-    if (projectState === undefined) return blocked(runtime);
-    if (!isJsonObject(projectState)) return unknown(runtime);
-    if (projectState.hasTrustDialogAccepted === true) {
-      return ready(runtime, { id: WORKSPACE_TRUST_CHECK_ID, status: "accepted" });
-    }
-    if (projectState.hasTrustDialogAccepted === false
-        || projectState.hasTrustDialogAccepted === null
-        || projectState.hasTrustDialogAccepted === undefined) {
-      return blocked(runtime);
-    }
-    return unknown(runtime);
-  } catch {
-    return unknown(runtime);
-  }
-}
-
-export async function checkRuntimeReadiness({
-  runtime,
-  projectRoot,
-  homeDir = homedir(),
-}) {
-  const selectedRuntime = runtime ?? "auto";
-  if (selectedRuntime !== "claude-code") {
-    return ready(selectedRuntime);
-  }
-  return checkClaudeCodeReadiness({ projectRoot, homeDir });
-}