@moretea-labs/forge 1.7.0 → 1.7.1

package/scripts/refresh-current-status.sh

@@ -1,469 +1,4 @@
 #!/bin/bash
 set -euo pipefail
-
-usage() {
-  cat <<'USAGE_EOF'
-Usage: scripts/refresh-current-status.sh [--write] [--clear] [--reason <reason>] [--target <branch>]
-
-Refresh the tracked tasks/current.md read model from repo-local workflow
-artifacts. By default this prints a preview. Use --write to update the file.
-USAGE_EOF
-}
-
-write=0
-clear=0
-reason="manual"
-target_override=""
-current_status_file="tasks/current.md"
-stale_after="24h"
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --write)
-      write=1
-      shift
-      ;;
-    --clear)
-      clear=1
-      shift
-      ;;
-    --reason)
-      [[ -n "${2:-}" ]] || { echo "refresh-current-status: --reason requires a value" >&2; exit 2; }
-      reason="$2"
-      shift 2
-      ;;
-    --target)
-      [[ -n "${2:-}" ]] || { echo "refresh-current-status: --target requires a value" >&2; exit 2; }
-      target_override="$2"
-      shift 2
-      ;;
-    --help|-h)
-      usage
-      exit 0
-      ;;
-    *)
-      echo "refresh-current-status: unknown argument: $1" >&2
-      usage >&2
-      exit 2
-      ;;
-  esac
-done
-
-policy_file=".ai/harness/policy.json"
-
-json_get() {
-  local path="$1"
-  local default_value="${2:-}"
-  local value
-
-  if [[ -f "$policy_file" ]] && command -v jq >/dev/null 2>&1; then
-    value="$(jq -r "$path // empty" "$policy_file" 2>/dev/null || true)"
-    if [[ -n "$value" && "$value" != "null" ]]; then
-      printf '%s' "$value"
-      return 0
-    fi
-  fi
-
-  printf '%s' "$default_value"
-}
-
-target_branch() {
-  if [[ -n "$target_override" ]]; then
-    printf '%s' "$target_override"
-    return 0
-  fi
-
-  local target
-  target="$(json_get '.worktree_strategy.merge_back.target' '')"
-  if [[ -z "$target" ]]; then
-    target="$(json_get '.worktree_strategy.base_branch' 'main')"
-  fi
-  printf '%s' "${target:-main}"
-}
-
-current_branch() {
-  local branch
-  branch="$(git branch --show-current 2>/dev/null || true)"
-  printf '%s' "${branch:-detached}"
-}
-
-source_commit() {
-  git rev-parse --short HEAD 2>/dev/null || printf '(none)'
-}
-
-timestamp_now() {
-  date '+%Y-%m-%dT%H:%M:%S%z'
-}
-
-file_metadata_value() {
-  local file="$1"
-  local label="$2"
-  [[ -f "$file" ]] || return 1
-  awk -v label="$label" '
-    $0 ~ "^> \\*\\*" label "\\*\\*:" {
-      sub("^> \\*\\*" label "\\*\\*: *", "")
-      gsub(/\r/, "")
-      print
-      exit
-    }
-  ' "$file" | xargs
-}
-
-read_plan_status() {
-  local plan_file="$1"
-  file_metadata_value "$plan_file" "Status" || true
-}
-
-normalize_plan_path() {
-  local worktree="$1"
-  local plan_path="$2"
-  if [[ -z "$plan_path" ]]; then
-    return 1
-  fi
-  if [[ "$plan_path" == /* ]]; then
-    printf '%s' "$plan_path"
-  else
-    printf '%s/%s' "$worktree" "$plan_path"
-  fi
-}
-
-append_unique_line() {
-  local line="$1"
-  [[ -n "$line" ]] || return 0
-  if ! printf '%s\n' "$active_refs" | grep -Fxq -- "$line"; then
-    active_refs="${active_refs}${line}"$'\n'
-  fi
-}
-
-inspect_worktree_active_state() {
-  local worktree="$1"
-  local rel_worktree="$2"
-  local marker plan_path plan_abs owner
-
-  for marker in ".ai/harness/active-plan" ".claude/.active-plan"; do
-    [[ -f "$worktree/$marker" ]] || continue
-    plan_path="$(cat "$worktree/$marker" 2>/dev/null | xargs || true)"
-    [[ -n "$plan_path" ]] || continue
-    plan_abs="$(normalize_plan_path "$worktree" "$plan_path")"
-    if [[ -f "$plan_abs" ]]; then
-      append_unique_line "- ${rel_worktree}: ${plan_path}"
-    else
-      append_unique_line "- ${rel_worktree}: stale active-plan marker -> ${plan_path}"
-    fi
-  done
-
-  if [[ -f "$worktree/.ai/harness/active-worktree" ]]; then
-    owner="$(cat "$worktree/.ai/harness/active-worktree" 2>/dev/null | xargs || true)"
-    if [[ -n "$owner" ]]; then
-      append_unique_line "- ${rel_worktree}: active-worktree owner -> ${owner}"
-    fi
-  fi
-}
-
-collect_active_work_refs() {
-  local root current_path worktree_path
-  active_refs=""
-  current_path="$(pwd -P 2>/dev/null || pwd)"
-  inspect_worktree_active_state "$current_path" "."
-
-  if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
-    while IFS= read -r worktree_path; do
-      [[ -n "$worktree_path" ]] || continue
-      [[ "$worktree_path" == "$current_path" ]] && continue
-      inspect_worktree_active_state "$worktree_path" "$worktree_path"
-    done < <(git worktree list --porcelain 2>/dev/null | awk '$1 == "worktree" { sub(/^worktree /, ""); print }')
-  fi
-
-  printf '%s' "$active_refs"
-}
-
-read_current_active_plan() {
-  local marker plan_path plan_abs current_path
-  current_path="$(pwd -P 2>/dev/null || pwd)"
-  for marker in ".ai/harness/active-plan" ".claude/.active-plan"; do
-    [[ -f "$marker" ]] || continue
-    plan_path="$(cat "$marker" 2>/dev/null | xargs || true)"
-    [[ -n "$plan_path" ]] || continue
-    plan_abs="$(normalize_plan_path "$current_path" "$plan_path")"
-    if [[ -f "$plan_abs" ]]; then
-      printf '%s' "$plan_path"
-      return 0
-    fi
-  done
-  return 1
-}
-
-next_plan_task() {
-  local plan_file="$1"
-  [[ -f "$plan_file" ]] || { printf '(none)'; return 0; }
-  awk '
-    BEGIN { in_section = 0 }
-    /^## Task Breakdown[[:space:]]*$/ { in_section = 1; next }
-    in_section && /^## / { exit }
-    in_section && /^[[:space:]]*-[[:space:]]\[[[:space:]]\][[:space:]]+/ {
-      line = $0
-      sub(/^[[:space:]]*-[[:space:]]\[[[:space:]]\][[:space:]]+/, "", line)
-      gsub(/\r/, "", line)
-      print line
-      found = 1
-      exit
-    }
-    END { if (!found) print "(none)" }
-  ' "$plan_file"
-}
-
-handoff_next_step() {
-  local handoff_file
-  handoff_file="$(json_get '.session.continuation_file' '.ai/harness/session/continuation.md')"
-  [[ -f "$handoff_file" ]] || { printf '(none)'; return 0; }
-  awk '
-    /^## Exact Next Step[[:space:]]*$/ { in_section = 1; next }
-    /^## / && in_section { exit }
-    in_section && /^[[:space:]]*-[[:space:]]+/ {
-      line = $0
-      sub(/^[[:space:]]*-[[:space:]]+/, "", line)
-      print line
-      found = 1
-      exit
-    }
-    END { if (!found) print "(none)" }
-  ' "$handoff_file"
-}
-
-checks_summary() {
-  local checks_file status source exit_code
-  checks_file="$(json_get '.harness.checks_file' '.ai/harness/checks/latest.json')"
-  [[ -s "$checks_file" ]] || { printf 'status=(none), source=(none), file=%s' "$checks_file"; return 0; }
-
-  if command -v jq >/dev/null 2>&1; then
-    status="$(jq -r '.status // "(none)"' "$checks_file" 2>/dev/null || printf '(unreadable)')"
-    source="$(jq -r '.source // "(none)"' "$checks_file" 2>/dev/null || printf '(unreadable)')"
-    exit_code="$(jq -r '.exit_code // "(none)"' "$checks_file" 2>/dev/null || printf '(unreadable)')"
-    printf 'status=%s, source=%s, exit_code=%s, file=%s' "$status" "$source" "$exit_code" "$checks_file"
-    return 0
-  fi
-
-  printf 'file=%s' "$checks_file"
-}
-
-workstream_summary() {
-  local workstreams_dir file count status current_slice source_plan
-  workstreams_dir="$(json_get '.tasks.workstreams_dir' 'tasks/workstreams')"
-  [[ -d "$workstreams_dir" ]] || { printf -- '- (none)\n'; return 0; }
-
-  count=0
-  while IFS= read -r file; do
-    [[ -n "$file" ]] || continue
-    status="$(file_metadata_value "$file" "Status" || printf 'unknown')"
-    current_slice="$(file_metadata_value "$file" "Current Slice" || printf 'unknown')"
-    source_plan="$(file_metadata_value "$file" "Source Plan" || printf 'unknown')"
-    printf -- '- `%s`: status=%s, current_slice=%s, source_plan=%s\n' "$file" "$status" "$current_slice" "$source_plan"
-    count=$((count + 1))
-    [[ "$count" -ge 8 ]] && break
-  done < <(find "$workstreams_dir" -type f -name '*.md' 2>/dev/null | sort)
-
-  [[ "$count" -gt 0 ]] || printf -- '- (none)\n'
-}
-
-sprint_backlog_progress() {
-  local sprint_file="$1"
-  awk -F '|' '
-    /^## Backlog[[:space:]]*$/ { in_section = 1; next }
-    in_section && /^## / { exit }
-    !in_section { next }
-    /^\|[[:space:]]*[0-9]+[[:space:]]*\|/ {
-      total++
-      cell = $3
-      gsub(/^[[:space:]]+|[[:space:]]+$/, "", cell)
-      if (cell ~ /^\[[xX]\]$/) done++
-    }
-    END { printf "%d/%d", done + 0, total + 0 }
-  ' "$sprint_file"
-}
-
-sprint_next_task() {
-  local sprint_file="$1"
-  awk -F '|' '
-    /^## Backlog[[:space:]]*$/ { in_section = 1; next }
-    in_section && /^## / { exit }
-    !in_section { next }
-    /^\|[[:space:]]*[0-9]+[[:space:]]*\|/ {
-      status = $3; task = $4
-      gsub(/^[[:space:]]+|[[:space:]]+$/, "", status)
-      gsub(/^[[:space:]]+|[[:space:]]+$/, "", task)
-      if (status == "[ ]") { print task; found = 1; exit }
-    }
-    END { if (!found) print "(none)" }
-  ' "$sprint_file"
-}
-
-sprint_summary() {
-  local marker sprint_file status
-  marker="$(json_get '.sprints.active_marker_file' '.ai/harness/sprint/active-sprint')"
-  if [[ ! -f "$marker" ]]; then
-    printf -- '- Sprint: (none)\n'
-    return 0
-  fi
-
-  sprint_file="$(cat "$marker" 2>/dev/null | xargs || true)"
-  if [[ -z "$sprint_file" || ! -f "$sprint_file" ]]; then
-    printf -- '- Sprint: stale active-sprint marker -> %s\n' "${sprint_file:-(empty)}"
-    return 0
-  fi
-
-  status="$(file_metadata_value "$sprint_file" "Status" || printf 'unknown')"
-  printf -- '- Sprint: `%s`\n' "$sprint_file"
-  printf -- '- Sprint Status: %s\n' "${status:-unknown}"
-  printf -- '- Backlog: %s\n' "$(sprint_backlog_progress "$sprint_file")"
-  printf -- '- Next Sprint Task: %s\n' "$(sprint_next_task "$sprint_file")"
-}
-
-git_status_summary() {
-  if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
-    printf 'not a git repository'
-    return 0
-  fi
-
-  local count
-  count="$(git_status_short_filtered | sed '/^[[:space:]]*$/d' | wc -l | tr -d ' ')"
-  if [[ "${count:-0}" -eq 0 ]]; then
-    printf 'clean'
-  else
-    printf '%s changed/untracked path(s)' "$count"
-  fi
-}
-
-git_status_short_filtered() {
-  git status --short 2>/dev/null | grep -Ev '^[? MARCUD!]{2}[[:space:]]+tasks/\.current\.md\.tmp\.[^[:space:]]+$' || true
-}
-
-git_status_files() {
-  if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
-    printf '(none)\n'
-    return 0
-  fi
-  local files
-  files="$(git_status_short_filtered | head -40)"
-  if [[ -n "$files" ]]; then
-    printf '%s\n' "$files"
-  else
-    printf '(none)\n'
-  fi
-}
-
-render_status() {
-  local now branch commit target active_work active_plan plan_status next_task status clear_note
-  local checks git_summary handoff_next
-  now="$(timestamp_now)"
-  branch="$(current_branch)"
-  commit="$(source_commit)"
-  target="$(target_branch)"
-  active_work="$(collect_active_work_refs)"
-  active_plan="$(read_current_active_plan || true)"
-  plan_status="(none)"
-  next_task="(none)"
-  if [[ -n "$active_plan" && -f "$active_plan" ]]; then
-    plan_status="$(read_plan_status "$active_plan")"
-    plan_status="${plan_status:-unknown}"
-    next_task="$(next_plan_task "$active_plan")"
-  elif [[ -n "$active_work" ]]; then
-    next_task="inspect active worktree marker(s)"
-  fi
-
-  if [[ "$clear" -eq 1 && -n "$active_work" ]]; then
-    status="ManualClearedWithActiveWork"
-    clear_note="Manual clear requested, but active work markers still exist. Idle was not written."
-  elif [[ -n "$active_work" ]]; then
-    status="Active"
-    clear_note="(none)"
-  else
-    status="Idle"
-    clear_note="(none)"
-  fi
-
-  checks="$(checks_summary)"
-  git_summary="$(git_status_summary)"
-  handoff_next="$(handoff_next_step)"
-
-  cat <<EOF_STATUS
-# Current Status Snapshot
-
-<!-- generated-by: forge refresh-current-status v1 -->
-<!-- updated_at: ${now} -->
-<!-- stale_after: ${stale_after} -->
-
-> **Status**: ${status}
-> **Updated At**: ${now}
-> **Source Branch**: ${branch}
-> **Source Commit**: ${commit}
-> **Target Branch**: ${target}
-> **Stale After**: ${stale_after}
-> **Reason**: ${reason}
-> **Derived From**: active-plan, active-sprint, workstreams, handoff, checks, git status
-
-This file is a tracked mainline snapshot derived from repo artifacts. It is not a live lock, not a kanban board, and not an implementation gate. If it is stale, read the source artifacts below.
-
-## Current Focus
-
-- Status: ${status}
-- Active Plan: ${active_plan:-(none)}
-- Plan Status: ${plan_status}
-- Next Task: ${next_task}
-- Clear Note: ${clear_note}
-
-## Mainline Snapshot Reading
-
-- Current worktree: \`tasks/current.md\`
-- Target branch snapshot: \`git show ${target}:tasks/current.md\`
-- Rule: non-target worktrees may read the target branch snapshot, but must verify against source artifacts before acting.
-
-## Active Work
-
-${active_work:-- (none)}
-## Active Sprint
-
-$(sprint_summary)
-## Workstreams
-
-$(workstream_summary)
-## Handoff
-
-- Exact Next Step: ${handoff_next}
-
-## Checks
-
-- ${checks}
-
-## Git Status
-
-- Summary: ${git_summary}
-
-\`\`\`
-$(git_status_files)
-\`\`\`
-
-## Source Artifacts
-
-- Plans: \`plans/plan-*.md\`
-- Active marker: \`.ai/harness/active-plan\`
-- Active worktree marker: \`.ai/harness/active-worktree\`
-- PRDs: \`plans/prds/*.prd.md\`
-- Sprints: \`$(json_get '.sprints.dir' 'plans/sprints')/*.sprint.md\`
-- Active sprint marker: \`.ai/harness/sprint/active-sprint\`
-- Workstreams: \`tasks/workstreams/**/*.md\`
-- Handoff: \`.ai/harness/session/continuation.md\`
-- Checks: \`.ai/harness/checks/latest.json\`
-EOF_STATUS
-}
-
-if [[ "$write" -eq 1 ]]; then
-  mkdir -p "$(dirname "$current_status_file")"
-  tmp_file="$(mktemp "$(dirname "$current_status_file")/.current.md.tmp.XXXXXX")"
-  trap 'rm -f "$tmp_file"' EXIT
-  render_status > "$tmp_file"
-  mv "$tmp_file" "$current_status_file"
-  trap - EXIT
-  echo "[CurrentStatus] Wrote ${current_status_file}."
-else
-  render_status
-fi
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$SCRIPT_DIR/lib/run-forge-helper.sh" "refresh-current-status.sh" "$@"

package/scripts/run-governed-gate.ts

@@ -17,6 +17,9 @@ export function stepsFor(gate: Gate): Step[] {
   if (gate === 'task') return [
     { label: 'typecheck', command: 'bun', args: ['run', 'check:type'], timeoutMs: 10 * 60_000 },
     { label: 'static architecture', command: 'bun', args: ['run', 'check:runtime-architecture'], timeoutMs: 5 * 60_000 },
+    { label: 'generated authority', command: 'node', args: ['scripts/sync-generated-authority.mjs', '--check'], timeoutMs: 2 * 60_000 },
+    { label: 'source duplication', command: 'node', args: ['scripts/check-source-duplication.mjs'], timeoutMs: 2 * 60_000 },
+    { label: 'controller UI bundle', command: 'bun', args: ['run', 'check:controller-ui'], timeoutMs: 5 * 60_000 },
     { label: 'test manifest', command: 'bun', args: ['run', 'check:test-governance'], timeoutMs: 5 * 60_000 },
     { label: 'affected tests', command: 'bun', args: ['run', 'test'], timeoutMs: 30 * 60_000 },
   ];

package/scripts/select-agent-context-blocks.sh

@@ -1,66 +1,4 @@
 #!/bin/bash
 set -euo pipefail
-
-repo="${1:-.}"
-repo="$(cd "$repo" && pwd)"
-config_file="${FORGE_CONTEXT_BLOCKS_FILE:-$repo/.ai/context/agent-context-blocks.txt}"
-registry_file="$repo/.ai/context/capabilities.json"
-
-emit_lines() {
-  sed -e 's/#.*$//' -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' | sed '/^$/d'
-}
-
-emit_existing_dirs() {
-  while IFS= read -r rel_dir; do
-    rel_dir="${rel_dir#./}"
-    rel_dir="${rel_dir%/}"
-    [[ -z "$rel_dir" || "$rel_dir" == "." ]] && continue
-    case "$rel_dir" in
-      /*|../*|*/../*|*\"*)
-        continue
-        ;;
-    esac
-    [[ -d "$repo/$rel_dir" ]] || continue
-    printf '%s\n' "$rel_dir"
-  done | sort -u
-}
-
-if [[ -f "$registry_file" ]]; then
-  if command -v bun >/dev/null 2>&1 && [[ -f "$repo/scripts/capability-resolver.ts" ]]; then
-    (cd "$repo" && bun scripts/capability-resolver.ts list --format prefixes 2>/dev/null || true) | emit_existing_dirs
-    exit 0
-  fi
-
-  if command -v node >/dev/null 2>&1; then
-    node - "$registry_file" <<'JS_EOF' | emit_existing_dirs
-const fs = require("fs");
-const registry = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
-for (const capability of registry.capabilities || []) {
-  for (const prefix of capability.prefixes || []) {
-    console.log(prefix);
-  }
-}
-JS_EOF
-    exit 0
-  fi
-fi
-
-context_blocks="${FORGE_CONTEXT_BLOCKS:-}"
-if [[ -n "$context_blocks" ]]; then
-  printf '%s\n' "$context_blocks" | tr ',:' '\n' | emit_lines | emit_existing_dirs
-  exit 0
-fi
-
-if [[ -f "$config_file" ]]; then
-  emit_lines < "$config_file" | emit_existing_dirs
-  exit 0
-fi
-
-find "$repo" \
-  \( -path "$repo/.git" -o -path "$repo/node_modules" -o -path "$repo/.ai" -o -path "$repo/.claude" -o -path "$repo/_ref" -o -path "$repo/_ops" -o -path "$repo/.worktrees" \) -prune -o \
-  \( -type f \( -name 'CLAUDE.md' -o -name 'AGENTS.md' \) \) -print 2>/dev/null | while IFS= read -r context_file; do
-    context_dir="$(dirname "$context_file")"
-    rel_dir="${context_dir#$repo/}"
-    [[ "$rel_dir" == "$context_dir" || "$rel_dir" == "." ]] && continue
-    printf '%s\n' "$rel_dir"
-  done | sort -u
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$SCRIPT_DIR/lib/run-forge-helper.sh" "select-agent-context-blocks.sh" "$@"