npm - okstra - Versions diffs - 0.49.0 → 0.51.0 - Mend

okstra 0.49.0 → 0.51.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (86) hide show

package/README.kr.md +8 -7
package/README.md +8 -7
package/bin/okstra +2 -0
package/docs/kr/architecture.md +23 -24
package/docs/kr/cli.md +6 -6
package/docs/project-structure-overview.md +13 -9
package/docs/superpowers/plans/2026-06-05-wizard-batch-prompts.md +559 -0
package/docs/superpowers/specs/2026-06-05-wizard-batch-prompts-design.md +121 -0
package/docs/task-process/error-analysis.md +1 -1
package/docs/task-process/final-verification.md +1 -1
package/docs/task-process/release-handoff.md +1 -1
package/docs/task-process/requirements-discovery.md +1 -1
package/package.json +1 -1
package/runtime/BUILD.json +2 -2
package/runtime/agents/SKILL.md +18 -14
package/runtime/agents/workers/claude-worker.md +4 -4
package/runtime/agents/workers/codex-worker.md +3 -3
package/runtime/agents/workers/gemini-worker.md +3 -3
package/runtime/agents/workers/report-writer-worker.md +3 -3
package/runtime/bin/lib/okstra/cli.sh +8 -1
package/runtime/bin/lib/okstra/globals.sh +3 -0
package/runtime/bin/lib/okstra/interactive.sh +14 -12
package/runtime/bin/lib/okstra/usage.sh +6 -0
package/runtime/bin/okstra-render-report-views.py +1 -1
package/runtime/bin/okstra-team-reconcile.sh +28 -0
package/runtime/bin/okstra.sh +2 -0
package/runtime/prompts/launch.template.md +4 -2
package/runtime/prompts/profiles/_common-contract.md +15 -15
package/runtime/prompts/profiles/_implementation-deliverable.md +1 -1
package/runtime/prompts/profiles/_implementation-executor.md +3 -3
package/runtime/prompts/profiles/_implementation-verifier.md +2 -2
package/runtime/prompts/profiles/error-analysis.md +1 -1
package/runtime/prompts/profiles/final-verification.md +2 -2
package/runtime/prompts/profiles/implementation-planning.md +10 -9
package/runtime/prompts/profiles/implementation.md +1 -1
package/runtime/prompts/profiles/improvement-discovery.md +5 -5
package/runtime/prompts/profiles/release-handoff.md +2 -2
package/runtime/prompts/profiles/requirements-discovery.md +2 -2
package/runtime/python/okstra_ctl/analysis_packet.py +259 -0
package/runtime/python/okstra_ctl/clarification_items.py +11 -11
package/runtime/python/okstra_ctl/context_cost.py +308 -0
package/runtime/python/okstra_ctl/migrate.py +2 -12
package/runtime/python/okstra_ctl/paths.py +22 -0
package/runtime/python/okstra_ctl/render.py +285 -126
package/runtime/python/okstra_ctl/render_final_report.py +32 -1
package/runtime/python/okstra_ctl/report_views.py +12 -12
package/runtime/python/okstra_ctl/run.py +510 -248
package/runtime/python/okstra_ctl/sequence.py +2 -5
package/runtime/python/okstra_ctl/team_reconcile.py +131 -0
package/runtime/python/okstra_ctl/wizard.py +219 -136
package/runtime/python/okstra_ctl/workflow.py +1 -1
package/runtime/python/okstra_ctl/worktree.py +13 -5
package/runtime/schemas/final-report-v1.0.schema.json +4 -0
package/runtime/skills/okstra-brief/SKILL.md +1 -1
package/runtime/skills/okstra-coding-preflight/SKILL.md +69 -0
package/runtime/skills/okstra-coding-preflight/architecture/hexagonal.md +116 -0
package/runtime/skills/okstra-coding-preflight/clean-code.md +254 -0
package/runtime/skills/okstra-coding-preflight/languages/java.md +64 -0
package/runtime/skills/okstra-coding-preflight/languages/javascript-typescript.md +87 -0
package/runtime/skills/okstra-coding-preflight/languages/kotlin.md +69 -0
package/runtime/skills/okstra-coding-preflight/languages/nodejs.md +66 -0
package/runtime/skills/okstra-coding-preflight/languages/python.md +179 -0
package/runtime/skills/okstra-coding-preflight/languages/rust.md +105 -0
package/runtime/skills/okstra-coding-preflight/languages/sql.md +68 -0
package/runtime/skills/okstra-context-loader/SKILL.md +12 -6
package/runtime/skills/okstra-convergence/SKILL.md +8 -8
package/runtime/skills/okstra-inspect/SKILL.md +100 -1
package/runtime/skills/okstra-report-writer/SKILL.md +27 -23
package/runtime/skills/okstra-run/SKILL.md +3 -1
package/runtime/skills/okstra-team-contract/SKILL.md +8 -5
package/runtime/templates/reports/final-report.template.md +188 -187
package/runtime/templates/reports/i18n/en.json +4 -4
package/runtime/templates/reports/i18n/ko.json +4 -4
package/runtime/templates/reports/implementation-planning-input.template.md +1 -1
package/runtime/templates/reports/release-handoff-input.template.md +1 -1
package/runtime/templates/reports/user-response.template.md +1 -1
package/runtime/templates/worker-prompt-preamble.md +4 -4
package/runtime/validators/lib/fixtures.sh +2 -2
package/runtime/validators/validate-implementation-plan-stages.py +9 -9
package/runtime/validators/validate-report-views.py +10 -10
package/runtime/validators/validate-run.py +36 -36
package/runtime/validators/validate_improvement_report.py +8 -8
package/src/_python-helper.mjs +3 -3
package/src/context-cost.mjs +27 -0
package/src/install.mjs +1 -0
package/src/uninstall.mjs +1 -0

package/runtime/python/okstra_ctl/analysis_packet.py ADDED Viewed

@@ -0,0 +1,259 @@
+"""Build the compact analysis-worker input packet for a task run."""
+from __future__ import annotations
+import re
+from pathlib import Path
+BRIEF_SECTIONS = (
+    "Identity",
+    "Request Summary",
+    "Current Context",
+    "Evidence and Source Materials",
+    "Task-Type Focus",
+    "Constraints and Risks",
+    "Out of Scope",
+    "Configuration References and Expected Values",
+    "Deployment Manifests and Expected Values",
+    "Questions for Workers",
+    "Expected Outputs",
+    "Task Continuity Notes",
+    "Available MCP Servers",
+)
+PROFILE_SECTIONS = (
+    "Primary focus areas",
+    "Expected output emphasis",
+    "Non-goals",
+    "Clarification request policy",
+)
+CLARIFICATION_SECTIONS = (
+    "Clarification Items",
+    "Clarification Response Carried In From Previous Run",
+)
+_FRONTMATTER_RE = re.compile(r"\A---\n(?P<body>.*?)\n---\n", re.DOTALL)
+def build_analysis_packet(
+    *,
+    task_key: str,
+    task_type: str,
+    task_brief_path: Path,
+    analysis_profile_path: Path,
+    reference_expectations_path: Path,
+    clarification_response_path: Path | None,
+    directive: str,
+    instruction_set_relative_path: str,
+) -> str:
+    """Return the primary compact input for Claude/Codex/Gemini analysers."""
+    brief_text = task_brief_path.read_text(encoding="utf-8")
+    profile_text = analysis_profile_path.read_text(encoding="utf-8")
+    reference_text = _read_optional(reference_expectations_path)
+    clarification_text = (
+        _read_optional(clarification_response_path)
+        if clarification_response_path else ""
+    )
+    parts = [_packet_frontmatter(brief_text, task_key)]
+    parts.extend(
+        _intro_block(
+            task_key,
+            instruction_set_relative_path,
+            bool(clarification_response_path),
+        )
+    )
+    parts.extend(_brief_block(brief_text))
+    parts.extend(_profile_block(task_type, profile_text))
+    parts.extend(_reference_block(reference_text))
+    parts.extend(_clarification_block(clarification_text))
+    parts.extend(_directive_block(directive))
+    return "\n".join(part.rstrip() for part in parts).rstrip() + "\n"
+def _packet_frontmatter(brief_text: str, task_key: str) -> str:
+    frontmatter = _extract_frontmatter(brief_text)
+    if frontmatter:
+        return (
+            f"---\n{frontmatter}\n"
+            'packetVersion: "1.0"\n'
+            "packetRole: analysis-worker-primary\n---"
+        )
+    return (
+        "---\n"
+        f'title: OKSTRA Analysis Packet - {task_key}\n'
+        'packetVersion: "1.0"\n'
+        "packetRole: analysis-worker-primary\n"
+        "---"
+    )
+def _intro_block(
+    task_key: str,
+    instruction_set: str,
+    has_clarification: bool,
+) -> list[str]:
+    lines = [
+        f"# OKSTRA Analysis Packet - {task_key}",
+        "",
+        "## Packet Role",
+        "",
+        "- This packet is the primary required reading for analysis workers.",
+        "- It extracts task-specific material from the source files listed below.",
+        "- Read source files only for evidence verification or missing detail.",
+        "",
+        "## Source Files",
+        "",
+        f"- Task brief: `{instruction_set}/task-brief.md`",
+        f"- Analysis profile: `{instruction_set}/analysis-profile.md`",
+        f"- Analysis material: `{instruction_set}/analysis-material.md`",
+        f"- Reference expectations: `{instruction_set}/reference-expectations.md`",
+    ]
+    if has_clarification:
+        lines.append(
+            f"- Clarification response: `{instruction_set}/clarification-response.md`"
+        )
+    return lines
+def _brief_block(brief_text: str) -> list[str]:
+    return [
+        "",
+        "## Task-Specific Brief Extract",
+        "",
+        _extract_sections(brief_text, BRIEF_SECTIONS),
+    ]
+def _profile_block(task_type: str, profile_text: str) -> list[str]:
+    profile_sections = _extract_sections(profile_text, PROFILE_SECTIONS)
+    profile_bullets = _extract_bullet_sections(profile_text, PROFILE_SECTIONS)
+    profile_focus = "\n\n".join(
+        part for part in (profile_sections, profile_bullets)
+        if part and not part.startswith("- No matching")
+    )
+    return [
+        "",
+        "## Phase Focus Extract",
+        "",
+        f"- Task Type: `{task_type}`",
+        "",
+        _extract_profile_prelude(profile_text),
+        "",
+        profile_focus or "- No matching source sections were available.",
+    ]
+def _reference_block(reference_text: str) -> list[str]:
+    body = reference_text.strip() or "- No reference expectations content was available."
+    return ["", "## Reference Expectations", "", body]
+def _clarification_block(clarification_text: str) -> list[str]:
+    if not clarification_text.strip():
+        return []
+    return [
+        "",
+        "## Clarification Carry-In Extract",
+        "",
+        _extract_sections(clarification_text, CLARIFICATION_SECTIONS),
+    ]
+def _directive_block(directive: str) -> list[str]:
+    if not directive:
+        return []
+    return ["", "## Directive", "", directive.strip()]
+def _extract_frontmatter(text: str) -> str:
+    match = _FRONTMATTER_RE.match(text)
+    return match.group("body").rstrip() if match else ""
+def _extract_profile_prelude(text: str) -> str:
+    lines = []
+    for line in text.splitlines():
+        if line.startswith(("{{INCLUDE:", "## ", "<!--", "- Team contract")):
+            break
+        if _top_level_bullet_heading(line) in PROFILE_SECTIONS:
+            break
+        if line.strip():
+            lines.append(line)
+    return "\n".join(lines).strip() or "- No profile prelude was available."
+def _extract_sections(text: str, headings: tuple[str, ...]) -> str:
+    sections = _section_map(text)
+    out = []
+    for heading in headings:
+        body = sections.get(heading, "").strip()
+        if body:
+            out.append(f"### {heading}\n\n{body}")
+    return "\n\n".join(out) or "- No matching source sections were available."
+def _extract_bullet_sections(text: str, headings: tuple[str, ...]) -> str:
+    heading_set = set(headings)
+    captured: list[tuple[str, list[str]]] = []
+    current_heading = ""
+    current_lines: list[str] = []
+    def flush_current() -> None:
+        nonlocal current_heading, current_lines
+        if current_heading and current_lines:
+            captured.append((current_heading, current_lines))
+        current_heading = ""
+        current_lines = []
+    for line in _strip_frontmatter(text).splitlines():
+        bullet_heading = _top_level_bullet_heading(line)
+        if bullet_heading:
+            if bullet_heading in heading_set:
+                flush_current()
+                current_heading = bullet_heading
+                current_lines = [line]
+                continue
+            flush_current()
+            continue
+        if current_heading:
+            if line.startswith("  ") or not line.strip():
+                current_lines.append(line)
+            else:
+                flush_current()
+    flush_current()
+    out = []
+    for heading, lines in captured:
+        body = "\n".join(lines).strip()
+        if body:
+            out.append(f"### {heading}\n\n{body}")
+    return "\n\n".join(out)
+def _top_level_bullet_heading(line: str) -> str:
+    if not line.startswith("- ") or ":" not in line:
+        return ""
+    label = line[2:].split(":", 1)[0].strip().strip("*")
+    return label
+def _section_map(text: str) -> dict[str, str]:
+    result: dict[str, list[str]] = {}
+    current = ""
+    for line in _strip_frontmatter(text).splitlines():
+        if line.startswith("## "):
+            current = line[3:].strip()
+            result.setdefault(current, [])
+            continue
+        if current:
+            result[current].append(line)
+    return {key: "\n".join(lines).strip() for key, lines in result.items()}
+def _strip_frontmatter(text: str) -> str:
+    match = _FRONTMATTER_RE.match(text)
+    return text[match.end():] if match else text
+def _read_optional(path: Path | None) -> str:
+    if path and path.is_file():
+        return path.read_text(encoding="utf-8")
+    return ""

package/runtime/python/okstra_ctl/clarification_items.py CHANGED Viewed

@@ -1,6 +1,6 @@
-"""Parse the ``## 5. Clarification Items`` table from a final-report markdown.
+"""Parse the ``## 1. Clarification Items`` table from a final-report markdown.
-The unified §5 table (introduced when §4.5.9 / §5.1 / §5.2 collapsed into a
+The unified §1 table (introduced when §4.5.9 / §5.1 / §5.2 collapsed into a
 single section) is the canonical home for every clarification an
 implementation-planning run owes the user — decisions, file attachments,
 single data points. Each row carries a ``Blocks`` column whose value picks
@@ -12,7 +12,7 @@ This module exposes one read function for that gate so both
 ``_validate_approved_plan`` (pre-implementation run-prep) and any later
 validator can share the same parsing logic.
-Legacy compatibility: reports written before the §5 unification used
+Legacy compatibility: reports written before the §1 unification used
 ``4.5.9 Open Questions`` + ``5.1 Additional Materials`` + ``5.2 Questions
 for the User`` and lacked a ``Blocks`` column. Those reports cannot be
 gate-checked by Blocks; the parser returns ``None`` to signal "schema
@@ -26,13 +26,13 @@ from pathlib import Path
 from typing import Optional
-SECTION_HEADING_PATTERN = re.compile(r"^##\s+5\.\s+Clarification Items\s*$", re.MULTILINE)
-NEXT_TOP_LEVEL_HEADING_PATTERN = re.compile(r"^##\s+(?!5\.)", re.MULTILINE)
+SECTION_HEADING_PATTERN = re.compile(r"^##\s+1\.\s+Clarification Items\s*$", re.MULTILINE)
+NEXT_TOP_LEVEL_HEADING_PATTERN = re.compile(r"^##\s+(?!1\.)", re.MULTILINE)
 @dataclass(frozen=True)
 class ClarificationItem:
-    """One row of the §5 table.
+    """One row of the §1 table.
     ``raw_*`` fields preserve the exact cell text (after backtick stripping)
     for diagnostics; canonical lowercased versions live in ``blocks`` /
@@ -77,9 +77,9 @@ def _is_separator_row(line: str) -> bool:
     return True
-def _section_5_slice(report_text: str) -> Optional[str]:
-    """Return the substring spanning the §5 section (heading exclusive of the
-    next ``##`` heading), or None if §5 is absent."""
+def _section_1_slice(report_text: str) -> Optional[str]:
+    """Return the substring spanning the §1 section (heading exclusive of the
+    next ``##`` heading), or None if §1 is absent."""
     start_match = SECTION_HEADING_PATTERN.search(report_text)
     if not start_match:
         return None
@@ -89,7 +89,7 @@ def _section_5_slice(report_text: str) -> Optional[str]:
 def parse_clarification_items(report_text: str) -> Optional[list[ClarificationItem]]:
-    """Return the list of §5 rows. ``None`` means "no unified §5 table
+    """Return the list of §1 rows. ``None`` means "no unified §1 table
     detected" (legacy report or missing section) — caller must NOT treat
     that as "table is empty".
@@ -97,7 +97,7 @@ def parse_clarification_items(report_text: str) -> Optional[list[ClarificationIt
     just the ``- 추가 정보 요청 없음.`` placeholder); that IS a confident
     "no approval-blocking items".
     """
-    section = _section_5_slice(report_text)
+    section = _section_1_slice(report_text)
     if section is None:
         return None

package/runtime/python/okstra_ctl/context_cost.py ADDED Viewed

@@ -0,0 +1,308 @@
+"""Read-side context cost estimator for prepared okstra task bundles.
+The estimator answers a narrow operational question: how much file/context
+surface does the current task bundle ask the lead, analysis workers, and
+report-writer to absorb? It does not mutate task artifacts.
+"""
+from __future__ import annotations
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Iterable
+from okstra_project import ResolverError, find_task_root, resolve_project_root
+INPUT_FILES = (
+    "task-brief.md",
+    "analysis-profile.md",
+    "analysis-material.md",
+    "reference-expectations.md",
+    "clarification-response.md",
+)
+TIMESTAMPED_ARTIFACT_RE = re.compile(r"\d{4}-\d{2}-\d{2}[_T]\d{2}-\d{2}-\d{2}")
+def _file_size(path: Path) -> int:
+    return path.stat().st_size if path.is_file() else 0
+def _count_files(paths: Iterable[Path]) -> tuple[int, int]:
+    file_count = 0
+    byte_count = 0
+    for path in paths:
+        if path.is_file():
+            file_count += 1
+            byte_count += path.stat().st_size
+    return file_count, byte_count
+def _all_files(root: Path) -> list[Path]:
+    if not root.exists():
+        return []
+    return [path for path in root.rglob("*") if path.is_file()]
+def _load_json(path: Path) -> dict:
+    if not path.is_file():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}
+def _resolve_task_root(target: str, project_root: str, cwd: str) -> tuple[Path, Path]:
+    target_path = Path(target).expanduser()
+    if target_path.exists():
+        task_root = target_path.resolve()
+        return task_root, _infer_project_root(task_root)
+    try:
+        resolved_project = Path(
+            resolve_project_root(explicit_root=project_root, cwd=cwd)
+        ).resolve()
+    except ResolverError as exc:
+        raise SystemExit(f"project root resolution failed: {exc}") from exc
+    task_root = find_task_root(resolved_project, target)
+    if task_root is None:
+        raise SystemExit(f"no task root for task key: {target}")
+    return task_root.resolve(), resolved_project
+def _infer_project_root(task_root: Path) -> Path:
+    parts = task_root.parts
+    if ".okstra" not in parts:
+        return task_root
+    idx = parts.index(".okstra")
+    return Path(*parts[:idx]).resolve()
+def _project_rel(path: Path, project_root: Path) -> str:
+    try:
+        return str(path.resolve().relative_to(project_root.resolve()))
+    except ValueError:
+        return str(path)
+def _find_current_run_dir(
+    task_root: Path, manifest: dict, project_root: Path
+) -> Path | None:
+    artifacts = manifest.get("artifacts", {})
+    prompt_dir = artifacts.get("workerPromptsDirectoryPath")
+    if isinstance(prompt_dir, str) and prompt_dir:
+        path = project_root / prompt_dir
+        if path.is_dir():
+            return path.parent
+    task_type = manifest.get("workflow", {}).get("currentPhase") or manifest.get("taskType")
+    if not isinstance(task_type, str) or not task_type:
+        return None
+    candidate = task_root / "runs" / task_type
+    return candidate if candidate.is_dir() else None
+def _latest_matching_file(directory: Path, pattern: str) -> Path | None:
+    matches = sorted(directory.glob(pattern))
+    if not matches:
+        return None
+    return max(matches, key=lambda path: path.stat().st_mtime)
+def _is_timestamped_legacy_artifact(path: Path) -> bool:
+    return bool(TIMESTAMPED_ARTIFACT_RE.search(path.name))
+def _instruction_set_metric(task_root: Path, project_root: Path) -> dict:
+    instruction_set = task_root / "instruction-set"
+    files = _all_files(instruction_set)
+    file_count, byte_count = _count_files(files)
+    packet = instruction_set / "analysis-packet.md"
+    legacy_packet = instruction_set / "task-packet.md"
+    return {
+        "path": _project_rel(instruction_set, project_root),
+        "fileCount": file_count,
+        "bytes": byte_count,
+        "analysisPacketBytes": _file_size(packet),
+        "legacyTaskPacketBytes": _file_size(legacy_packet),
+    }
+def _lead_phase1_metric(
+    task_root: Path, run_dir: Path | None, manifest: dict, project_root: Path
+) -> dict:
+    active_path = None
+    artifacts = manifest.get("artifacts", {})
+    active_rel = artifacts.get("activeRunContextPath")
+    if isinstance(active_rel, str) and active_rel:
+        active_path = project_root / active_rel
+    if active_path and active_path.is_file():
+        instruction_set = task_root / "instruction-set"
+        packet = instruction_set / "analysis-packet.md"
+        files = [
+            task_root / "task-manifest.json",
+            active_path,
+            instruction_set / "analysis-profile.md",
+            packet if packet.is_file() else instruction_set / "task-brief.md",
+        ]
+        mode = "active-run-context"
+    else:
+        current_phase = manifest.get("workflow", {}).get("currentPhase") or manifest.get("taskType", "")
+        run_manifest = None
+        team_state = None
+        if run_dir is not None:
+            manifests_dir = run_dir / "manifests"
+            state_dir = run_dir / "state"
+            run_manifest = _latest_matching_file(
+                manifests_dir, f"run-manifest-{current_phase}-*.json"
+            )
+            team_state = _latest_matching_file(
+                state_dir, f"team-state-{current_phase}-*.json"
+            )
+        files = [
+            task_root / "task-manifest.json",
+            task_root / "instruction-set" / "task-brief.md",
+            task_root / "instruction-set" / "analysis-profile.md",
+        ]
+        if run_manifest:
+            files.append(run_manifest)
+        if team_state:
+            files.append(team_state)
+        mode = "legacy-five-file"
+    file_count, byte_count = _count_files(files)
+    return {
+        "mode": mode,
+        "fileCount": file_count,
+        "bytes": byte_count,
+        "files": [_project_rel(path, project_root) for path in files if path.is_file()],
+    }
+def _analysis_worker_metric(task_root: Path, project_root: Path) -> dict:
+    instruction_set = task_root / "instruction-set"
+    full_contract_files = [instruction_set / name for name in INPUT_FILES]
+    preamble = Path.home() / ".okstra" / "templates" / "worker-prompt-preamble.md"
+    if not preamble.is_file():
+        repo_preamble = (
+            Path(__file__).resolve().parents[2]
+            / "templates"
+            / "worker-prompt-preamble.md"
+        )
+        preamble = repo_preamble
+    full_contract_files.append(preamble)
+    full_file_count, full_byte_count = _count_files(full_contract_files)
+    packet = instruction_set / "analysis-packet.md"
+    legacy_packet = instruction_set / "task-packet.md"
+    primary_packet = packet if packet.is_file() else legacy_packet
+    has_packet = primary_packet.is_file()
+    packet_files = [primary_packet, preamble] if has_packet else []
+    packet_file_count, packet_byte_count = _count_files(packet_files)
+    mode = "analysis-packet-primary" if packet.is_file() else "full-input-contract"
+    byte_count = packet_byte_count if packet.is_file() else full_byte_count
+    file_count = packet_file_count if packet.is_file() else full_file_count
+    current_files = packet_files if packet.is_file() else full_contract_files
+    reduction_percent = 0
+    if full_byte_count and has_packet:
+        reduction_percent = round((1 - packet_byte_count / full_byte_count) * 100)
+    return {
+        "mode": mode,
+        "fileCount": file_count,
+        "bytesPerWorker": byte_count,
+        "legacyFullContractBytesPerWorker": full_byte_count,
+        "legacyFullContractFileCount": full_file_count,
+        "estimatedPacketModeBytesPerWorker": packet_byte_count,
+        "estimatedReductionPercent": reduction_percent,
+        "files": [_project_rel(path, project_root) for path in current_files if path.is_file()],
+        "legacyFullContractFiles": [
+            _project_rel(path, project_root)
+            for path in full_contract_files
+            if path.is_file()
+        ],
+    }
+def _report_writer_metric(run_dir: Path | None, task_root: Path, project_root: Path) -> dict:
+    instruction_set = task_root / "instruction-set"
+    files = [instruction_set / name for name in INPUT_FILES]
+    files.extend([
+        instruction_set / "final-report-template.md",
+        instruction_set / "final-report-schema.json",
+    ])
+    if run_dir is not None:
+        worker_results = run_dir / "worker-results"
+        files.extend(
+            path for path in worker_results.glob("*.md")
+            if "-audit-" not in path.name and "report-writer" not in path.name
+        )
+        convergence = _latest_matching_file(
+            run_dir / "state", f"convergence-{run_dir.name}-*.json"
+        )
+        if convergence:
+            files.append(convergence)
+    file_count, byte_count = _count_files(files)
+    return {
+        "mode": "raw-synthesis-inputs",
+        "fileCount": file_count,
+        "bytes": byte_count,
+        "files": [_project_rel(path, project_root) for path in files if path.is_file()],
+    }
+def analyze_task_bundle(task_root: Path, project_root: Path) -> dict:
+    manifest = _load_json(task_root / "task-manifest.json")
+    run_dir = _find_current_run_dir(task_root, manifest, project_root)
+    all_task_files = _all_files(task_root)
+    task_file_count, task_bytes = _count_files(all_task_files)
+    current_run_file_count, current_run_bytes = _count_files(_all_files(run_dir)) if run_dir else (0, 0)
+    legacy_timestamp_files = [
+        path for path in (task_root / "runs").rglob("*")
+        if path.is_file() and _is_timestamped_legacy_artifact(path)
+    ]
+    return {
+        "ok": True,
+        "taskRoot": _project_rel(task_root, project_root),
+        "projectRoot": str(project_root),
+        "taskKey": manifest.get("taskKey", ""),
+        "taskType": manifest.get("taskType", ""),
+        "currentRunPath": _project_rel(run_dir, project_root) if run_dir else "",
+        "totals": {
+            "taskFileCount": task_file_count,
+            "taskBytes": task_bytes,
+            "currentRunFileCount": current_run_file_count,
+            "currentRunBytes": current_run_bytes,
+            "legacyTimestampFileCount": len(legacy_timestamp_files),
+        },
+        "instructionSet": _instruction_set_metric(task_root, project_root),
+        "leadPhase1": _lead_phase1_metric(task_root, run_dir, manifest, project_root),
+        "analysisWorker": _analysis_worker_metric(task_root, project_root),
+        "reportWriter": _report_writer_metric(run_dir, task_root, project_root),
+    }
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Estimate context/file-read cost for an okstra task bundle."
+    )
+    parser.add_argument("target", help="task root path or task-key")
+    parser.add_argument("--project-root", default="", help="project root for task-key lookup")
+    parser.add_argument("--cwd", default=".", help="cwd for project root resolution")
+    args = parser.parse_args(argv)
+    task_root, project_root = _resolve_task_root(args.target, args.project_root, args.cwd)
+    result = analyze_task_bundle(task_root, project_root)
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/runtime/python/okstra_ctl/migrate.py CHANGED Viewed

@@ -23,6 +23,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional
+from okstra_ctl.worktree import is_git_work_tree
 from okstra_project.dirs import (
     LEGACY_OKSTRA_DIR_NAME,
     LEGACY_OKSTRA_RELATIVE,
@@ -112,7 +113,7 @@ def prepare_migration_plan(
             f"Remove it manually if you intend to overwrite, then re-run."
         )
-    use_git = _is_git_worktree(project_root)
+    use_git = is_git_work_tree(project_root)
     parent = source.parent  # <project>/.project-docs
     remove_empty_parent = _would_be_empty_after_remove(parent, source)
@@ -194,17 +195,6 @@ def _resolve_okstra_home(override: Optional[Path]) -> Path:
     return Path.home() / ".okstra"
-def _is_git_worktree(project_root: Path) -> bool:
-    try:
-        rc = subprocess.run(
-            ["git", "rev-parse", "--show-toplevel"],
-            cwd=str(project_root), capture_output=True, text=True, check=False,
-        )
-    except (OSError, FileNotFoundError):
-        return False
-    return rc.returncode == 0 and bool(rc.stdout.strip())
 def _would_be_empty_after_remove(parent: Path, child: Path) -> bool:
     """Return True if `parent` would be empty after `child` is moved out."""
     if not parent.is_dir():