@moretea-labs/forge 1.7.0 → 1.7.1

package/scripts/stage-runtime-release.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import { realpathSync } from 'fs';
 import { resolve } from 'path';
 import { assertRuntimeReleaseFiles, stageRuntimeRelease, type CandidateRuntimeStageReceiptV1 } from '../src/runtime/root/release-materialize';
 
@@ -18,7 +19,7 @@ const controllerHome = resolve(requiredOption(args, '--controller-home'));
 const sourceRoot = resolve(requiredOption(args, '--source-root'));
 const expectedHead = requiredOption(args, '--expected-head');
 if (!/^[a-f0-9]{40}$/i.test(expectedHead)) throw new Error('RUNTIME_RELEASE_CANDIDATE_EXPECTED_HEAD_INVALID');
-if (sourceRoot !== resolve(process.cwd())) throw new Error('RUNTIME_RELEASE_CANDIDATE_CWD_MISMATCH');
+if (realpathSync(sourceRoot) !== realpathSync(process.cwd())) throw new Error('RUNTIME_RELEASE_CANDIDATE_CWD_MISMATCH');
 
 const staged = stageRuntimeRelease({ controllerHome, sourceRoot });
 assertRuntimeReleaseFiles(staged);

package/scripts/summarize-failures.sh

@@ -1,125 +1,4 @@
 #!/bin/bash
 set -euo pipefail
-
-if [[ -f ".ai/hooks/lib/workflow-state.sh" ]]; then
-  # shellcheck source=/dev/null
-  . ".ai/hooks/lib/workflow-state.sh"
-fi
-
-usage() {
-  cat <<'USAGE_EOF'
-Usage: scripts/summarize-failures.sh [--file <path>] [--run-id <id>]
-USAGE_EOF
-}
-
-resolve_js_runtime() {
-  if command -v bun >/dev/null 2>&1; then
-    printf 'bun'
-    return 0
-  fi
-
-  if [[ -x "${HOME}/.bun/bin/bun" ]]; then
-    printf '%s' "${HOME}/.bun/bin/bun"
-    return 0
-  fi
-
-  if command -v node >/dev/null 2>&1; then
-    printf 'node'
-    return 0
-  fi
-
-  return 1
-}
-
-if declare -F workflow_failure_log_file >/dev/null 2>&1; then
-  log_file="$(workflow_failure_log_file)"
-else
-  log_file=".ai/harness/failures/latest.jsonl"
-fi
-filter_run_id=""
-js_runtime=""
-js_code=""
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --file)
-      [[ -n "${2:-}" ]] || { echo "Error: --file requires a value" >&2; usage; exit 2; }
-      log_file="$2"
-      shift 2
-      ;;
-    --run-id)
-      [[ -n "${2:-}" ]] || { echo "Error: --run-id requires a value" >&2; usage; exit 2; }
-      filter_run_id="$2"
-      shift 2
-      ;;
-    --help|-h)
-      usage
-      exit 0
-      ;;
-    *)
-      echo "Unknown argument: $1" >&2
-      usage
-      exit 2
-      ;;
-  esac
-done
-
-if [[ ! -f "$log_file" ]]; then
-  echo "[FailureSummary] No failure log found at $log_file"
-  exit 0
-fi
-
-js_runtime="$(resolve_js_runtime || true)"
-if [[ -z "$js_runtime" ]]; then
-  echo "[FailureSummary] Missing JavaScript runtime (expected bun or node)" >&2
-  exit 1
-fi
-
-js_code="$(cat <<'NODE_EOF'
-const fs = require("fs");
-
-const file = process.env.JSONL_FILE;
-const filterRunId = process.env.FILTER_RUN_ID || "";
-
-const rows = fs
-  .readFileSync(file, "utf-8")
-  .split("\n")
-  .map((line) => line.trim())
-  .filter(Boolean)
-  .map((line) => JSON.parse(line))
-  .filter((row) => !filterRunId || row.run_id === filterRunId);
-
-if (rows.length === 0) {
-  console.log(
-    filterRunId
-      ? `[FailureSummary] No failure records found for run_id=${filterRunId}`
-      : "[FailureSummary] No failure records found"
-  );
-  process.exit(0);
-}
-
-const classCounts = new Map();
-const guardCounts = new Map();
-
-for (const row of rows) {
-  classCounts.set(row.failure_class, (classCounts.get(row.failure_class) || 0) + 1);
-  guardCounts.set(row.guard, (guardCounts.get(row.guard) || 0) + 1);
-}
-
-const sortEntries = (map) =>
-  [...map.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
-
-const latestRunId = rows[rows.length - 1]?.run_id || "unknown";
-console.log(`[FailureSummary] records=${rows.length} run_id=${filterRunId || latestRunId}`);
-console.log("Failure classes:");
-for (const [name, count] of sortEntries(classCounts)) {
-  console.log(`- ${name}: ${count}`);
-}
-console.log("Guards:");
-for (const [name, count] of sortEntries(guardCounts)) {
-  console.log(`- ${name}: ${count}`);
-}
-NODE_EOF
-)"
-
-JSONL_FILE="$log_file" FILTER_RUN_ID="$filter_run_id" "$js_runtime" -e "$js_code"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$SCRIPT_DIR/lib/run-forge-helper.sh" "summarize-failures.sh" "$@"

package/scripts/switch-plan.sh

@@ -1,153 +1,4 @@
 #!/bin/bash
-# Select the current plan for this worktree.
-# Other worktrees may hold different active-plan markers concurrently.
-
 set -euo pipefail
-
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-if REPO_ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null)"; then
-  cd "$REPO_ROOT"
-elif [[ "$SCRIPT_DIR" == */.ai/harness/scripts ]]; then
-  cd "$SCRIPT_DIR/../../.."
-else
-  cd "$SCRIPT_DIR/.."
-fi
-
-usage() {
-  cat <<'USAGE_EOF'
-Usage: scripts/switch-plan.sh --plan <plan-file>
-       scripts/switch-plan.sh --list
-
-Options:
-  --plan <path>   Switch to the specified plan (saves current state, restores target)
-  --list          List all non-archived plans with active marker
-USAGE_EOF
-}
-
-extract_status() {
-  local file="$1"
-  awk '/\*\*Status\*\*:/ {sub(/^.*\*\*Status\*\*: */, ""); gsub(/\r/, ""); print; exit}' "$file" | xargs
-}
-
-ACTIVE_PLAN_MARKER=".ai/harness/active-plan"
-LEGACY_ACTIVE_PLAN_MARKER=".claude/.active-plan"
-ACTIVE_WORKTREE_MARKER=".ai/harness/active-worktree"
-
-read_active_plan_marker() {
-  local marker_file="$1"
-  local marker_plan
-
-  if [[ -f "$marker_file" ]]; then
-    marker_plan="$(cat "$marker_file" 2>/dev/null | xargs)"
-    if [[ -n "$marker_plan" && -f "$marker_plan" ]]; then
-      printf '%s' "$marker_plan"
-      return 0
-    fi
-  fi
-
-  return 1
-}
-
-get_active_plan() {
-  read_active_plan_marker "$ACTIVE_PLAN_MARKER" \
-    || read_active_plan_marker "$LEGACY_ACTIVE_PLAN_MARKER"
-}
-
-write_active_plan_marker() {
-  local plan_file="$1"
-  mkdir -p "$(dirname "$ACTIVE_PLAN_MARKER")" "$(dirname "$LEGACY_ACTIVE_PLAN_MARKER")" "$(dirname "$ACTIVE_WORKTREE_MARKER")"
-  printf '%s' "$plan_file" > "$ACTIVE_PLAN_MARKER"
-  printf '%s' "$plan_file" > "$LEGACY_ACTIVE_PLAN_MARKER"
-  pwd -P > "$ACTIVE_WORKTREE_MARKER"
-}
-
-do_list() {
-  local active
-  active="$(get_active_plan || true)"
-
-  if [[ ! -d "plans" ]]; then
-    echo "No plans/ directory found."
-    return
-  fi
-
-  local found=0
-  while IFS= read -r plan; do
-    [[ -n "$plan" ]] || continue
-    found=1
-    local status marker
-    status="$(extract_status "$plan")"
-    status="${status:-(unknown)}"
-    if [[ "$plan" == "$active" ]]; then
-      marker="[*]"
-    else
-      marker="   "
-    fi
-    printf '%s %s  Status: %s\n' "$marker" "$plan" "$status"
-  done < <(find plans -maxdepth 1 -type f -name 'plan-*.md' 2>/dev/null | sort)
-
-  if [[ "$found" -eq 0 ]]; then
-    echo "No plans found in plans/"
-  fi
-}
-
-do_switch() {
-  local target_plan="$1"
-
-  if [[ ! -f "$target_plan" ]]; then
-    echo "Error: plan file not found: $target_plan" >&2
-    exit 1
-  fi
-
-  local current_plan
-  current_plan="$(get_active_plan || true)"
-
-  if [[ "$current_plan" == "$target_plan" ]]; then
-    echo "[PlanSwitch] Already on $target_plan"
-    return 0
-  fi
-
-  write_active_plan_marker "$target_plan"
-  echo "[PlanSwitch] Selected $target_plan for worktree $(pwd -P)"
-  echo "[PlanSwitch] tasks/todos.md is a deferred-goal ledger and was left unchanged."
-}
-
-# --- Main ---
-target_plan=""
-mode=""
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --plan)
-      [[ -n "${2:-}" ]] || { echo "Error: --plan requires a value" >&2; usage; exit 2; }
-      target_plan="$2"
-      mode="switch"
-      shift 2
-      ;;
-    --list)
-      mode="list"
-      shift
-      ;;
-    --help|-h)
-      usage
-      exit 0
-      ;;
-    *)
-      echo "Unknown argument: $1" >&2
-      usage
-      exit 2
-      ;;
-  esac
-done
-
-case "$mode" in
-  list)
-    do_list
-    ;;
-  switch)
-    do_switch "$target_plan"
-    ;;
-  *)
-    usage
-    exit 2
-    ;;
-esac
+exec "$SCRIPT_DIR/lib/run-forge-helper.sh" "switch-plan.sh" "$@"

package/scripts/sync-brain-docs.sh

@@ -1,381 +1,4 @@
 #!/bin/bash
 set -euo pipefail
-
-usage() {
-  cat <<'USAGE_EOF'
-Usage: scripts/sync-brain-docs.sh [--manifest PATH] (--all | --changed PATH | --check) [--dry-run] [--require-vault]
-
-Synchronizes explicitly opted-in repo docs to the local default brain file vault.
-Only manifest entries with sync.direction=repo-to-brain are eligible.
-USAGE_EOF
-}
-
-manifest_path=".ai/harness/brain-manifest.json"
-mode_all=0
-mode_check=0
-dry_run=0
-require_vault=0
-changed_paths=()
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --manifest)
-      manifest_path="${2:-}"
-      shift 2
-      ;;
-    --all)
-      mode_all=1
-      shift
-      ;;
-    --changed)
-      changed_paths+=("${2:-}")
-      shift 2
-      ;;
-    --check)
-      mode_check=1
-      shift
-      ;;
-    --dry-run)
-      dry_run=1
-      shift
-      ;;
-    --require-vault)
-      require_vault=1
-      shift
-      ;;
-    --help|-h)
-      usage
-      exit 0
-      ;;
-    *)
-      echo "sync-brain-docs: unknown argument: $1" >&2
-      usage >&2
-      exit 2
-      ;;
-  esac
-done
-
-resolve_js_runtime() {
-  if command -v node >/dev/null 2>&1; then
-    printf 'node'
-    return 0
-  fi
-
-  if command -v bun >/dev/null 2>&1; then
-    printf 'bun'
-    return 0
-  fi
-
-  return 1
-}
-
-runtime="$(resolve_js_runtime || true)"
-if [[ -z "$runtime" ]]; then
-  echo "[BrainSync] Missing node or bun to read brain manifest: $manifest_path" >&2
-  exit 1
-fi
-
-if [[ "$mode_all" -eq 0 && "$mode_check" -eq 0 && "${#changed_paths[@]}" -eq 0 ]]; then
-  echo "sync-brain-docs: choose --all, --changed PATH, or --check" >&2
-  usage >&2
-  exit 2
-fi
-
-changed_json='[]'
-if [[ "${#changed_paths[@]}" -gt 0 ]]; then
-  changed_json="$(
-    "$runtime" -e '
-const values = process.argv.slice(1);
-process.stdout.write(JSON.stringify(values));
-' "${changed_paths[@]}"
-  )"
-fi
-
-"$runtime" - "$manifest_path" "$mode_all" "$mode_check" "$dry_run" "$require_vault" "$changed_json" <<'JS_EOF'
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-
-const [, , manifestArg, allArg, checkArg, dryRunArg, requireVaultArg, changedJson] = process.argv;
-const repoRoot = fs.realpathSync(process.cwd());
-const manifestPath = path.resolve(repoRoot, manifestArg || ".ai/harness/brain-manifest.json");
-const modeAll = allArg === "1";
-const modeCheck = checkArg === "1";
-const dryRun = dryRunArg === "1";
-const requireVault = requireVaultArg === "1";
-const changedPaths = JSON.parse(changedJson || "[]").map(normalizeRepoPathInput).filter(Boolean);
-let issues = 0;
-let synced = 0;
-let skipped = 0;
-
-function issue(message) {
-  console.log(`[BrainSync] ${message}`);
-  issues += 1;
-}
-
-function warn(message) {
-  console.log(`[BrainSync] warning: ${message}`);
-}
-
-function readJson(filePath, label) {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf8"));
-  } catch (_error) {
-    issue(`Cannot read ${label}: ${path.relative(repoRoot, filePath) || filePath}`);
-    return null;
-  }
-}
-
-function normalizeSlashes(value) {
-  return String(value || "").replaceAll(path.sep, "/");
-}
-
-function isInside(root, candidate) {
-  const rel = path.relative(root, candidate);
-  return rel === "" || (!!rel && !rel.startsWith("..") && !path.isAbsolute(rel));
-}
-
-function realpathOrNull(filePath) {
-  try {
-    return fs.realpathSync(filePath);
-  } catch (_error) {
-    return null;
-  }
-}
-
-function firstExistingParent(filePath) {
-  let cursor = path.resolve(filePath);
-  const missingParts = [];
-  while (!fs.existsSync(cursor)) {
-    const parent = path.dirname(cursor);
-    if (parent === cursor) return null;
-    missingParts.unshift(path.basename(cursor));
-    cursor = parent;
-  }
-  return { parent: cursor, rest: missingParts.join(path.sep) };
-}
-
-function normalizeRepoPathInput(value) {
-  if (!value) return "";
-  const raw = String(value);
-  const absolute = path.isAbsolute(raw) ? raw : path.resolve(repoRoot, raw);
-  const real = realpathOrNull(absolute);
-  const rel = path.relative(repoRoot, real || absolute);
-  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
-    return "";
-  }
-  return normalizeSlashes(rel);
-}
-
-function safeRepoPath(value, label, id) {
-  const raw = String(value || "");
-  if (!raw || raw.includes("\n") || raw.includes("\r") || path.isAbsolute(raw)) {
-    issue(`Entry ${id} has invalid ${label}: ${raw || "(empty)"}`);
-    return null;
-  }
-  const normalized = path.normalize(raw);
-  if (normalized === ".." || normalized.startsWith(`..${path.sep}`)) {
-    issue(`Entry ${id} ${label} escapes repo: ${raw}`);
-    return null;
-  }
-  return normalizeSlashes(normalized);
-}
-
-function stripWildcard(logicalPath) {
-  return String(logicalPath || "").replace(/\/\*$/, "/");
-}
-
-const brainRoot = process.env.FORGE_BRAIN_ROOT ||
-  path.join(os.homedir(), "Library", "Mobile Documents", "com~apple~CloudDocs", "brain");
-
-function logicalToLocal(logicalPath, id) {
-  const value = String(logicalPath || "");
-  if (!value.startsWith("brain/")) {
-    issue(`Entry ${id} brain_path must start with brain/: ${value || "(empty)"}`);
-    return null;
-  }
-  const rel = value.slice("brain/".length);
-  if (!rel || rel.includes("\n") || rel.includes("\r")) {
-    issue(`Entry ${id} has invalid brain_path: ${value || "(empty)"}`);
-    return null;
-  }
-  const local = path.resolve(brainRoot, rel);
-  const root = path.resolve(brainRoot);
-  if (!isInside(root, local)) {
-    issue(`Entry ${id} brain_path escapes brain root: ${value}`);
-    return null;
-  }
-  return local;
-}
-
-function validateSourceInsideRepo(sourceFile, sourcePath, id) {
-  if (!isInside(repoRoot, sourceFile)) {
-    issue(`Entry ${id} source file escapes repo: ${sourcePath}`);
-    return false;
-  }
-  const real = realpathOrNull(sourceFile);
-  if (real && !isInside(repoRoot, real)) {
-    issue(`Entry ${id} source file symlink escapes repo: ${sourcePath}`);
-    return false;
-  }
-  return true;
-}
-
-function validateTargetInsideBrainRoot(targetPath, brainPath, id) {
-  const brainRootReal = realpathOrNull(brainRoot);
-  if (!brainRootReal) return true;
-
-  const targetReal = realpathOrNull(targetPath);
-  if (targetReal && !isInside(brainRootReal, targetReal)) {
-    issue(`Entry ${id} brain file symlink escapes brain root: ${brainPath}`);
-    return false;
-  }
-
-  const parentInfo = firstExistingParent(targetPath);
-  if (parentInfo) {
-    const parentReal = realpathOrNull(parentInfo.parent);
-    const effectiveTarget = parentReal
-      ? path.resolve(parentReal, parentInfo.rest)
-      : path.resolve(targetPath);
-    if (!isInside(brainRootReal, effectiveTarget)) {
-      issue(`Entry ${id} brain path escapes brain root through symlink: ${brainPath}`);
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function syncConfig(entry) {
-  const sync = entry.sync && typeof entry.sync === "object" ? entry.sync : {};
-  const direction = sync.direction || entry.sync_direction || "";
-  if (direction !== "repo-to-brain") return null;
-  if (sync.enabled === false || entry.sync_enabled === false) return null;
-  const id = entry.id || "(missing id)";
-  return {
-    id,
-    sourcePath: sync.source_path || entry.source_path || entry.repo_path,
-    brainPath: sync.brain_path || entry.brain_path,
-  };
-}
-
-if (!fs.existsSync(manifestPath)) {
-  issue(`Missing brain manifest: ${path.relative(repoRoot, manifestPath) || manifestPath}`);
-  process.exit(1);
-}
-
-const manifest = readJson(manifestPath, "brain manifest");
-if (!manifest) process.exit(1);
-
-const entries = Array.isArray(manifest.entries) ? manifest.entries : [];
-const defaultPrefix = stripWildcard(manifest.default_brain_path);
-const eligible = [];
-
-for (const entry of entries) {
-  const config = syncConfig(entry);
-  if (!config) continue;
-  const sourcePath = safeRepoPath(config.sourcePath, "sync source_path", config.id);
-  const brainPath = String(config.brainPath || "");
-  if (brainPath && defaultPrefix && !brainPath.startsWith(defaultPrefix)) {
-    issue(`Entry ${config.id} brain_path is outside default_brain_path: ${brainPath}`);
-  }
-  const targetPath = logicalToLocal(brainPath, config.id);
-  if (!sourcePath || !targetPath) continue;
-  const sourceFile = path.resolve(repoRoot, sourcePath);
-  if (!validateSourceInsideRepo(sourceFile, sourcePath, config.id)) continue;
-  eligible.push({ id: config.id, sourcePath, sourceFile, brainPath, targetPath });
-}
-
-const selected = eligible.filter((entry) => {
-  if (modeAll || modeCheck) return true;
-  return changedPaths.includes(entry.sourcePath);
-});
-
-if (selected.length > 0 && !modeCheck && !fs.existsSync(brainRoot)) {
-  issue(`vault root unavailable: ${brainRoot}`);
-}
-
-if (selected.length > 0 && modeCheck && !fs.existsSync(brainRoot)) {
-  const message = `vault root unavailable; skipped sync drift checks: ${brainRoot}`;
-  if (requireVault) issue(message);
-  else warn(message);
-}
-
-for (const entry of selected) {
-  if (!fs.existsSync(entry.sourceFile)) {
-    issue(`Entry ${entry.id} source file is missing: ${entry.sourcePath}`);
-    continue;
-  }
-
-  if (!fs.existsSync(brainRoot)) {
-    skipped += 1;
-    continue;
-  }
-
-  if (!validateTargetInsideBrainRoot(entry.targetPath, entry.brainPath, entry.id)) {
-    continue;
-  }
-
-  let sourceContent;
-  try {
-    sourceContent = fs.readFileSync(entry.sourceFile, "utf8");
-  } catch (error) {
-    const code = error && error.code ? ` (${error.code})` : "";
-    issue(`Entry ${entry.id} source file is unreadable: ${entry.sourcePath}${code}`);
-    continue;
-  }
-
-  const targetExists = fs.existsSync(entry.targetPath);
-  let targetContent = null;
-  if (targetExists) {
-    try {
-      targetContent = fs.readFileSync(entry.targetPath, "utf8");
-    } catch (error) {
-      const code = error && error.code ? ` (${error.code})` : "";
-      const message = `Entry ${entry.id} brain file is unreadable: ${entry.brainPath}${code}`;
-      if (modeCheck && !requireVault) {
-        warn(`${message}; skipped sync drift check`);
-        skipped += 1;
-        continue;
-      }
-      issue(message);
-      continue;
-    }
-  }
-
-  if (modeCheck) {
-    if (!targetExists) {
-      issue(`Entry ${entry.id} brain file is missing: ${entry.brainPath}`);
-    } else if (targetContent !== sourceContent) {
-      issue(`Entry ${entry.id} brain file differs from source: ${entry.sourcePath} -> ${entry.brainPath}`);
-    }
-    continue;
-  }
-
-  if (targetExists && targetContent === sourceContent) {
-    skipped += 1;
-    continue;
-  }
-
-  if (dryRun) {
-    console.log(`[BrainSync] would sync ${entry.sourcePath} -> ${entry.brainPath}`);
-    synced += 1;
-    continue;
-  }
-
-  fs.mkdirSync(path.dirname(entry.targetPath), { recursive: true });
-  fs.writeFileSync(entry.targetPath, sourceContent);
-  console.log(`[BrainSync] synced ${entry.sourcePath} -> ${entry.brainPath}`);
-  synced += 1;
-}
-
-if (issues > 0) process.exit(1);
-
-if (selected.length === 0 && (modeAll || modeCheck)) {
-  console.log("[BrainSync] no repo-to-brain entries");
-} else if (synced === 0 && selected.length > 0 && !modeCheck) {
-  console.log(`[BrainSync] up to date (${skipped} checked)`);
-} else if (modeCheck && selected.length > 0) {
-  console.log("[BrainSync] OK");
-}
-JS_EOF
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$SCRIPT_DIR/lib/run-forge-helper.sh" "sync-brain-docs.sh" "$@"