okstra 0.173.0 → 0.174.0

package/src/commands/execute/worktree-status.mjs

@@ -0,0 +1,109 @@
+import { runPythonSnippet, emitJsonError } from "../../lib/python-helper.mjs";
+
+const USAGE = `okstra worktree-status — clean-worktree check that ignores okstra's own scaffolding
+
+Usage:
+  okstra worktree-status [--path <dir>] [--check-clean]
+
+  --path <dir>     directory to inspect (default: current directory)
+  --check-clean    exit 1 when the tree is dirty (default: always exit 0)
+
+okstra provisions \`.okstra\` plus the configured sync entries (\`.project-docs\`,
+\`.claude\`, …) into every task worktree, and an \`implementation\` stage worktree
+sits inside its task worktree. A bare \`git status --porcelain\` therefore never
+comes back empty there, so a plan step asserting a clean tree with one fails on
+okstra's scaffolding rather than on the stage's own work. This command asks the
+same question against source paths only — the exact gate okstra's own handoff
+and stage-integration steps use.
+
+Use it as the assertion in a plan step:
+  okstra worktree-status --check-clean && git tag -f stage-<N>-exit
+
+Output: JSON { ok, path, clean, entries, excluded }. \`entries\` holds the
+\`git status --short\` rows that made it dirty; \`excluded\` lists the paths left
+out of the question.
+`;
+
+function parseArgs(args) {
+  const opts = { path: ".", checkClean: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--check-clean") {
+      opts.checkClean = true;
+    } else if (arg === "--path") {
+      i += 1;
+      if (i >= args.length) throw new Error("--path requires a directory");
+      opts.path = args[i];
+    } else if (arg.startsWith("--path=")) {
+      opts.path = arg.slice("--path=".length);
+    } else {
+      throw new Error(`unknown argument '${arg}'`);
+    }
+  }
+  if (!opts.path) throw new Error("--path requires a directory");
+  return opts;
+}
+
+const SCRIPT = `
+import json, sys
+from pathlib import Path
+from okstra_ctl.worktree import (
+    dirty_entries_excluding_okstra,
+    is_git_work_tree,
+    nested_worktree_excludes,
+    okstra_clean_gate_excludes,
+)
+
+path = Path(sys.argv[1]).resolve()
+check_clean = sys.argv[2] == "1"
+
+if not path.is_dir():
+    print(json.dumps({"ok": False, "stage": "input",
+                      "reason": f"not a directory: {path}"}))
+    sys.exit(2)
+if not is_git_work_tree(path):
+    print(json.dumps({"ok": False, "stage": "input",
+                      "reason": f"not inside a git work tree: {path}"}))
+    sys.exit(2)
+
+entries = dirty_entries_excluding_okstra(path)
+excluded = [*okstra_clean_gate_excludes(path), *nested_worktree_excludes(path)]
+print(json.dumps({
+    "ok": True,
+    "path": str(path),
+    "clean": not entries,
+    "entries": entries,
+    "excluded": excluded,
+}, ensure_ascii=False, indent=2))
+sys.exit(1 if (check_clean and entries) else 0)
+`;
+
+export async function run(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+  let opts;
+  try {
+    opts = parseArgs(args);
+  } catch (err) {
+    process.stderr.write(`error: ${err.message}\n\n${USAGE}`);
+    return 2;
+  }
+
+  const result = await runPythonSnippet({
+    script: SCRIPT,
+    args: [opts.path, opts.checkClean ? "1" : "0"],
+  });
+
+  if (result.code !== 0 && !result.stdout.trim()) {
+    emitJsonError({
+      stage: "python",
+      reason: `python invocation failed: ${result.stderr.trim() || "no output"}`,
+    });
+    return 1;
+  }
+
+  process.stdout.write(result.stdout);
+  return result.code;
+}

package/src/commands/lifecycle/install.mjs

@@ -37,7 +37,6 @@ const BIN_ENTRYPOINTS = [
   "okstra-kimi-exec.sh",
   "okstra-provider-exec.py",
   "okstra-trace-cleanup.sh",
-  "okstra-subagent-reclaim.sh",
   "okstra-team-reconcile.sh",
   "okstra-central.sh",
   "okstra-token-usage.py",
@@ -1136,7 +1135,6 @@ export async function runEnsureInstalled(args) {
   if (!(await dirExists(paths.pythonpath))) reasons.push(`missing ${paths.pythonpath}`);
   if (!(await dirExists(paths.agents))) reasons.push(`missing agents dir ${paths.agents}`);
   for (const relative of [
-    ["schemas", "final-report-v1.0.schema.json"],
     ["schemas", "final-report-v2.0.schema.json"],
     ["templates", "reports", "final-report-v2.template.md"],
     ["templates", "reports", "html", "base.template.html"],

package/src/commands/report/finalize.mjs

@@ -7,16 +7,23 @@ Usage:
   okstra report-finalize --project-root <dir> --run-manifest <path> \\
     --report <final-report-<task-type>-<seq>.md> [--team-state <path>]
 
-Runs the four Phase 7 steps in their contractual order against one final-report:
+Runs the six Phase 7 steps in their contractual order against one final-report:
 
-  1. token-usage       substitute real token/cost numbers into the data.json
-  2. render-views      write the schema-v2 task-specific *.html sibling; v1
+  1. project-activity  project the run's activity events into the data.json
+  2. check-source      verify the data.json is the English SSOT
+  3. token-usage       substitute real token/cost numbers into the data.json
+  4. render-views      write the schema-v2 task-specific *.html sibling; v1
                        keeps the legacy conditional interactive view
-  3. spawn-followups   turn section 4 rows into task stubs
-  4. validate-run      validate the finished run artifacts
+  5. spawn-followups   turn section 4 rows into task stubs
+  6. validate-run      validate the finished run artifacts
 
 Every step is idempotent, so re-running after a fixed failure is safe. The
-sequence stops at the first non-zero exit and reports which step failed.
+sequence stops at the first non-zero exit and reports which step failed, except
+token-usage: its input is the lead session log, so a failure there does not
+take the html, follow-ups and validation after it down with it. Whenever a step
+exits non-zero the command prints the --only flags that resume the sequence
+from the earliest failing step — follow those rather than rerunning the failing
+step alone, which would leave the html rendered before the tokens landed.
 
 This is the same code path the Codex lead adapter runs automatically after its
 report-writer completes, so a Claude-led and a Codex-led run finalize

package/runtime/bin/okstra-subagent-reclaim.sh

@@ -1,26 +0,0 @@
-#!/usr/bin/env bash
-#
-# okstra-subagent-reclaim.sh — SubagentStop / TaskCompleted 훅 엔트리.
-#
-# stdin(JSON)은 읽고 버린다: 어느 worker 가 끝났든 활성 run 전체의 "완료" pane 만
-# 회수하므로 session_id 매핑이 필요 없다. active.jsonl 의 각 활성 run 에 대해
-# okstra-trace-cleanup.sh --reclaim-completed 를 호출한다 — 완료 판정(pane_reclaim)이
-# cross-run 안전을 보장하므로 다른 run 의 진행 중 pane 은 건드리지 않는다.
-#
-# 훅은 세션 진행을 절대 막지 않는다: 모든 실패는 조용히 삼키고 항상 exit 0.
-set -u
-
-cat >/dev/null 2>&1 || true   # drain stdin
-
-_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-home="${OKSTRA_HOME:-$HOME/.okstra}"
-# pane_reclaim 패키지는 repo 레이아웃(scripts/okstra_ctl)과 설치 레이아웃
-# ($OKSTRA_HOME/lib/python) 양쪽에 있을 수 있으므로 둘 다 PYTHONPATH 에 둔다.
-export PYTHONPATH="${_dir}:${home}/lib/python${PYTHONPATH:+:$PYTHONPATH}"
-
-while IFS= read -r run_dir; do
-  [[ -n "$run_dir" ]] || continue
-  "$_dir/okstra-trace-cleanup.sh" --reclaim-completed --run-dir "$run_dir" >/dev/null 2>&1 || true
-done < <(python3 -m okstra_ctl.pane_reclaim --active-dirs "$home" 2>/dev/null || true)
-
-exit 0