@sushanglewis/lincoln 1.5.0 → 1.5.1

package/framework/scripts/init-lincoln-branch.sh

@@ -0,0 +1,300 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Initialize a Lincoln issue work package on the current feature branch.
+# The work package is scoped to the issue and lives on the feature branch only.
+#
+# Usage:
+#   scripts/init-lincoln-branch.sh --issue-number <number> [--session-id <id>] [--design-id <id>] [--process-slug <slug>] [--workflow <name>] [--push] [--no-commit] [--auto]
+#
+# Legacy usage (non-issue-driven):
+#   scripts/init-lincoln-branch.sh <session-id> <design-id> [--process-slug <slug>] [--push]
+#
+# Example:
+#   scripts/init-lincoln-branch.sh --issue-number 21 --session-id 2026-07-08-stakeholder --design-id checkout-redesign --push
+#
+# Flags:
+#   --no-commit    Create the issue package and workflow-stage.yaml but do not git-add/commit.
+#   --auto         Non-interactive mode used by hooks; skips prompts and tolerates a dirty working tree.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+cd "$ROOT"
+
+ISSUE_NUMBER=""
+SESSION_ID=""
+DESIGN_ID=""
+PUSH=""
+PROCESS_SLUG=""
+NO_COMMIT=""
+AUTO=""
+WORKFLOW_NAME=""
+
+# Detect legacy positional invocation
+if [[ "${1:-}" != --* && $# -ge 2 ]]; then
+    SESSION_ID="${1:-}"
+    DESIGN_ID="${2:-}"
+    shift 2
+fi
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --issue-number)
+            ISSUE_NUMBER="${2:-}"
+            if [[ -z "$ISSUE_NUMBER" ]]; then
+                echo "ERROR: --issue-number requires a value"
+                exit 1
+            fi
+            shift 2
+            ;;
+        --session-id)
+            SESSION_ID="${2:-}"
+            if [[ -z "$SESSION_ID" ]]; then
+                echo "ERROR: --session-id requires a value"
+                exit 1
+            fi
+            shift 2
+            ;;
+        --design-id)
+            DESIGN_ID="${2:-}"
+            if [[ -z "$DESIGN_ID" ]]; then
+                echo "ERROR: --design-id requires a value"
+                exit 1
+            fi
+            shift 2
+            ;;
+        --push)
+            PUSH="--push"
+            shift
+            ;;
+        --no-commit)
+            NO_COMMIT="1"
+            shift
+            ;;
+        --auto)
+            AUTO="1"
+            shift
+            ;;
+        --workflow)
+            WORKFLOW_NAME="${2:-}"
+            if [[ -z "$WORKFLOW_NAME" ]]; then
+                echo "ERROR: --workflow requires a value"
+                exit 1
+            fi
+            shift 2
+            ;;
+        --process-slug)
+            PROCESS_SLUG="${2:-}"
+            if [[ -z "$PROCESS_SLUG" ]]; then
+                echo "ERROR: --process-slug requires a value"
+                exit 1
+            fi
+            shift 2
+            ;;
+        *)
+            echo "ERROR: unknown argument: $1"
+            echo "Usage: $(basename "$0") --issue-number <number> [--session-id <id>] [--design-id <id>] [--process-slug <slug>] [--workflow <name>] [--push] [--no-commit] [--auto]"
+            exit 1
+            ;;
+    esac
+done
+
+# Validate issue number is numeric
+if [[ -n "$ISSUE_NUMBER" && ! "$ISSUE_NUMBER" =~ ^[0-9]+$ ]]; then
+    echo "ERROR: --issue-number must be a positive integer: $ISSUE_NUMBER"
+    exit 1
+fi
+
+# Require issue number for issue-driven initialization
+if [[ -z "$ISSUE_NUMBER" && ( -z "$SESSION_ID" || -z "$DESIGN_ID" ) ]]; then
+    echo "Usage: $(basename "$0") --issue-number <number> [--session-id <id>] [--design-id <id>] [--process-slug <slug>] [--workflow <name>] [--push] [--no-commit] [--auto]"
+    exit 1
+fi
+
+# Derive defaults for session/design from issue number
+if [[ -n "$ISSUE_NUMBER" ]]; then
+    TODAY="$(date -u +%Y-%m-%d)"
+    SESSION_ID="${SESSION_ID:-$TODAY-issue-$ISSUE_NUMBER}"
+    DESIGN_ID="${DESIGN_ID:-issue-$ISSUE_NUMBER}"
+fi
+
+# Validate design_id (kebab-case)
+if ! [[ "$DESIGN_ID" =~ ^[a-z0-9]+(-[a-z0-9]+)*$ ]]; then
+    echo "ERROR: design_id must be kebab-case lowercase: $DESIGN_ID"
+    exit 1
+fi
+
+# Validate session_id pattern (YYYY-MM-DD-descriptive-name)
+if ! [[ "$SESSION_ID" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}-[a-z0-9-]+$ ]]; then
+    echo "ERROR: session_id should match YYYY-MM-DD-descriptive-name: $SESSION_ID"
+    exit 1
+fi
+
+RUN_ID="$(date -u +%Y%m%d%H%M%S)-$(openssl rand -hex 4 2>/dev/null || echo $$)"
+
+if [[ -z "$PROCESS_SLUG" ]]; then
+    if [[ -n "$ISSUE_NUMBER" ]]; then
+        PROCESS_SLUG="issue-$ISSUE_NUMBER"
+    elif [[ -n "${LINCOLN_PROCESS_SLUG:-}" ]]; then
+        PROCESS_SLUG="$LINCOLN_PROCESS_SLUG"
+    elif [[ -n "${CONDUCTOR_WORKSPACE_NAME:-}" ]]; then
+        PROCESS_SLUG="$CONDUCTOR_WORKSPACE_NAME"
+    else
+        PROCESS_SLUG="${SESSION_ID}-${DESIGN_ID}"
+    fi
+fi
+
+if ! [[ "$PROCESS_SLUG" =~ ^[a-z0-9]+(-[a-z0-9]+)*$ ]]; then
+    echo "ERROR: process_slug must be kebab-case lowercase: $PROCESS_SLUG"
+    exit 1
+fi
+
+# Determine current branch / create feature branch if on main
+CURRENT_BRANCH="$(git branch --show-current 2>/dev/null || true)"
+if [[ -z "$CURRENT_BRANCH" ]]; then
+    echo "ERROR: not on a git branch"
+    exit 1
+fi
+
+if [[ "$CURRENT_BRANCH" == "main" ]]; then
+    if [[ -z "$ISSUE_NUMBER" ]]; then
+        echo "ERROR: must provide --issue-number to create a feature branch from main"
+        exit 1
+    fi
+    BRANCH_NAME="issue-$ISSUE_NUMBER"
+    echo "==> Creating issue branch: $BRANCH_NAME"
+    git checkout -b "$BRANCH_NAME"
+    CURRENT_BRANCH="$BRANCH_NAME"
+elif [[ -n "$ISSUE_NUMBER" && "$CURRENT_BRANCH" != "issue-$ISSUE_NUMBER" && "$CURRENT_BRANCH" != issue-$ISSUE_NUMBER-* ]]; then
+    echo "WARNING: current branch '$CURRENT_BRANCH' does not match the 'issue-$ISSUE_NUMBER' naming convention"
+    echo "         (see README.md 分支级工作流与阶段状态: issue ↔ branch ↔ PR must correspond end-to-end)."
+    echo "         Continuing anyway; ensure this is the intended feature branch."
+fi
+
+# Ensure working tree is clean before initializing package (skip in --auto mode)
+if [[ -z "$AUTO" ]] && { ! git diff --quiet || ! git diff --cached --quiet; }; then
+    echo "ERROR: working tree or index is not clean. Commit or stash changes first."
+    exit 1
+fi
+
+BRANCH_NAME="$CURRENT_BRANCH"
+PROCESS_ROOT="$PROCESS_SLUG"
+
+# Create branch-scoped process package directories.
+# Document templates stay read-only in .claude/templates/issue-package/; agents
+# reference them on demand instead of copying .tpl files into the package.
+echo "==> Creating Lincoln issue work package: $PROCESS_ROOT/"
+mkdir -p "$PROCESS_ROOT"
+
+# Initialize workflow-stage.yaml for this issue
+python3 - "$ISSUE_NUMBER" "$SESSION_ID" "$DESIGN_ID" "$BRANCH_NAME" "$RUN_ID" "$ROOT" "$PROCESS_SLUG" "$WORKFLOW_NAME" <<'PY'
+import sys
+from pathlib import Path
+import yaml
+
+issue_number, session_id, design_id, branch_name, run_id, root_path, process_slug, workflow_name = sys.argv[1:9]
+root = Path(root_path)
+state_path = root / process_slug / "workflow-stage.yaml"
+
+workflow_name = workflow_name or "interview-to-knowledge"
+workflow_path = root / ".claude" / "workflows" / f"{workflow_name}.yaml"
+if not workflow_path.is_file():
+    sys.exit(f"ERROR: workflow not found: {workflow_path}")
+workflow_data = yaml.safe_load(workflow_path.read_text(encoding="utf-8")).get("workflow", {})
+steps = workflow_data.get("steps", [])
+first_stage = steps[0].get("id", "ingest") if steps else "ingest"
+
+template_path = root / ".claude" / "templates" / "issue-package" / "workflow-stage.yaml"
+state = yaml.safe_load(template_path.read_text(encoding="utf-8"))
+state["workflow"]["name"] = workflow_data.get("name", workflow_name)
+state["workflow"]["version"] = workflow_data.get("version", "1.0.0")
+state["workflow"]["template"] = workflow_name
+state["current_run"]["run_id"] = run_id
+state["current_run"]["branch"] = branch_name
+state["current_run"]["started_at"] = __import__("datetime").datetime.now(__import__("datetime").timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+state["current_run"]["last_updated_at"] = state["current_run"]["started_at"]
+state["current_run"]["current_stage"] = first_stage
+state["current_run"]["status"] = "in_progress"
+state["current_run"]["issue_number"] = issue_number
+state["current_run"]["execution_mode"] = "team"
+state["current_run"]["variables"]["session_id"] = session_id
+state["current_run"]["variables"]["design_id"] = design_id
+state["current_run"]["variables"]["issue_number"] = issue_number
+state["current_run"]["variables"]["process_slug"] = process_slug
+state["recovery"]["can_resume_from"] = first_stage
+
+state_path.write_text(yaml.dump(state, allow_unicode=True, sort_keys=False), encoding="utf-8")
+print(f"Initialized workflow-stage.yaml for issue #{issue_number} on branch {branch_name} (workflow: {workflow_name}, first stage: {first_stage})")
+PY
+
+# Add gitkeep files for empty directories to ensure they are tracked.
+# The HTML portal lives at {process_slug}/index.html; deliverable docs/prototypes
+# go under {process_slug}/pages/. Raw inputs stay in interviews/, openspec/,
+# recordings/, and handoffs/pm-to-ux/.
+for dir in \
+    "$PROCESS_ROOT/pages/docs/snapshots" \
+    "$PROCESS_ROOT/pages/prototype/app/main" \
+    "$PROCESS_ROOT/pages/prototype/app/onboarding" \
+    "$PROCESS_ROOT/pages/prototype/app/settings" \
+    "$PROCESS_ROOT/pages/prototype/app/org" \
+    "$PROCESS_ROOT/pages/prototype/app/tray" \
+    "$PROCESS_ROOT/pages/prototype/app/overlays" \
+    "$PROCESS_ROOT/pages/prototype/web/dashboard" \
+    "$PROCESS_ROOT/pages/prototype/web/list" \
+    "$PROCESS_ROOT/pages/prototype/web/form" \
+    "$PROCESS_ROOT/pages/prototype/web/detail" \
+    "$PROCESS_ROOT/pages/prototype/mobile/home" \
+    "$PROCESS_ROOT/pages/prototype/mobile/chat" \
+    "$PROCESS_ROOT/pages/prototype/mobile/settings" \
+    "$PROCESS_ROOT/pages/prototype/mobile/profile" \
+    "$PROCESS_ROOT/handoffs" \
+    "$PROCESS_ROOT/handoffs/pm-to-ux" \
+    "$PROCESS_ROOT/interviews/$SESSION_ID" \
+    "$PROCESS_ROOT/openspec/changes" \
+    "$PROCESS_ROOT/openspec/specs" \
+    "$PROCESS_ROOT/recordings" \
+    ".github/lincoln-sync-queue"; do
+    mkdir -p "$dir"
+    touch "$dir/.gitkeep"
+done
+
+# Copy the HTML portal scaffold from read-only templates.
+# Templates stay in .claude/templates/issue-package/; only the rendered shell and
+# shared assets are copied into the package.
+echo "==> Copying HTML portal scaffold"
+cp "$ROOT/.claude/templates/issue-package/index.html.tpl" "$PROCESS_ROOT/index.html"
+mkdir -p "$PROCESS_ROOT/assets/js"
+cp -R "$ROOT/.claude/templates/issue-package/assets/"* "$PROCESS_ROOT/assets/"
+
+# Generate the portal index (assets/js/package-data.js) from workflow-stage.yaml.
+python3 "$ROOT/scripts/lincoln_index.py" --state-file "$PROCESS_ROOT/workflow-stage.yaml"
+
+if [[ -n "$NO_COMMIT" ]]; then
+    echo "==> Skipping git commit (--no-commit requested)"
+else
+    # Stage and commit initial state
+    echo "==> Committing initial issue work package"
+    git add .
+    git commit -m "chore: initialize Lincoln issue work package for #$ISSUE_NUMBER
+
+- branch: $BRANCH_NAME
+- process_slug: $PROCESS_SLUG
+- session_id: $SESSION_ID
+- design_id: $DESIGN_ID
+- run_id: $RUN_ID
+
+Issue work package is branch-scoped and will not be merged to main."
+fi
+
+if [[ "$PUSH" == "--push" ]]; then
+    echo "==> Pushing branch to remote"
+    git push -u origin "$BRANCH_NAME"
+fi
+
+echo ""
+echo "Lincoln issue work package created for issue #$ISSUE_NUMBER"
+echo "Branch: $BRANCH_NAME"
+echo "Process package: $PROCESS_ROOT/"
+echo "Portal: $PROCESS_ROOT/index.html"
+echo "Next step: place the recording in $PROCESS_ROOT/recordings/ and say:"
+echo "  '处理一下这个访谈录音 $PROCESS_ROOT/recordings/<recording-file>'"

package/framework/scripts/init-project.sh

@@ -0,0 +1,184 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Lincoln Project Initialization Script
+# Run this after creating a new project from the Lincoln GitHub template.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+if [ -x "$PROJECT_ROOT/.venv/bin/python3" ]; then
+  PYTHON="$PROJECT_ROOT/.venv/bin/python3"
+elif [ -x "$PROJECT_ROOT/venv/bin/python3" ]; then
+  PYTHON="$PROJECT_ROOT/venv/bin/python3"
+else
+  PYTHON="python3"
+fi
+
+cd "$PROJECT_ROOT"
+
+echo "🚀 Initializing Lincoln project at $PROJECT_ROOT"
+
+# ---------------------------------------------------------------------------
+# 1. Verify git repository
+# ---------------------------------------------------------------------------
+if ! git rev-parse --git-dir > /dev/null 2>&1; then
+  echo "❌ Error: not a git repository. Please run 'git init' first."
+  exit 1
+fi
+
+INITIAL_STATUS="$(git status --porcelain)"
+
+# ---------------------------------------------------------------------------
+# 2. Ensure placeholder files exist for durable tracked directories
+# ---------------------------------------------------------------------------
+mkdir -p products oss/clones knowledge/assets knowledge/01-interviews knowledge/02-requirements knowledge/03-features knowledge/04-decisions knowledge/06-references .context
+
+[ -f products/.gitkeep ] || touch products/.gitkeep
+[ -f oss/clones/.gitkeep ] || touch oss/clones/.gitkeep
+[ -f knowledge/assets/.gitkeep ] || touch knowledge/assets/.gitkeep
+[ -f knowledge/01-interviews/.gitkeep ] || touch knowledge/01-interviews/.gitkeep
+[ -f knowledge/02-requirements/.gitkeep ] || touch knowledge/02-requirements/.gitkeep
+[ -f knowledge/03-features/.gitkeep ] || touch knowledge/03-features/.gitkeep
+[ -f knowledge/04-decisions/.gitkeep ] || touch knowledge/04-decisions/.gitkeep
+[ -f knowledge/06-references/.gitkeep ] || touch knowledge/06-references/.gitkeep
+
+if [ ! -f products/README.md ]; then
+  cat > products/README.md <<'EOF'
+# Products
+
+Put first-party product code under `products/<product-slug>/`.
+
+Lincoln process artifacts live in feature-branch process packages, not here.
+EOF
+fi
+
+if [ ! -f oss/README.md ]; then
+  cat > oss/README.md <<'EOF'
+# OSS
+
+Track third-party open-source candidates in `oss/projects.yaml`.
+
+Local clones belong under `oss/clones/` and are gitignored.
+EOF
+fi
+
+if [ ! -f oss/projects.yaml ]; then
+  cat > oss/projects.yaml <<'EOF'
+projects: []
+EOF
+fi
+
+# ---------------------------------------------------------------------------
+# 3. Check dependencies (warn only; bootstrap should have installed them)
+# ---------------------------------------------------------------------------
+if [ -f "$PROJECT_ROOT/.claude/skills/dependencies.yaml" ]; then
+  if ! "$PYTHON" "$PROJECT_ROOT/scripts/lincoln-setup.py" check --root "$PROJECT_ROOT" > /dev/null 2>&1; then
+    echo "⚠️  Lincoln dependency check found missing items."
+    echo "   Ask Claude to finish the bootstrap before creating issue work packages."
+  else
+    echo "✅ Lincoln dependency check passed"
+  fi
+fi
+
+# ---------------------------------------------------------------------------
+# 4. Ensure OpenSpec config is configured
+# ---------------------------------------------------------------------------
+CONFIG_FILE=".github/openspec-config.yml"
+NEEDS_INIT=false
+
+if [ ! -f "$CONFIG_FILE" ]; then
+  NEEDS_INIT=true
+else
+  if grep -qE "owner:\s*your-org" "$CONFIG_FILE" || grep -qE "name:\s*your-product-repo" "$CONFIG_FILE"; then
+    NEEDS_INIT=true
+  fi
+fi
+
+if [ "$NEEDS_INIT" = true ]; then
+  echo ""
+  echo "📝 $CONFIG_FILE needs the real GitHub owner and repo name."
+  OWNER="${LINCOLN_REPO_OWNER:-}"
+  NAME="${LINCOLN_REPO_NAME:-}"
+
+  if [ -z "$OWNER" ] || [ -z "$NAME" ]; then
+    REMOTE_URL="$(git remote get-url origin 2>/dev/null || true)"
+    if [[ "$REMOTE_URL" =~ github\.com[:/]([^/]+)/([^/]+?)(\.git)?$ ]]; then
+      OWNER="${BASH_REMATCH[1]}"
+      NAME="${BASH_REMATCH[2]}"
+    fi
+  fi
+
+  if [ -n "$OWNER" ] && [ -n "$NAME" ]; then
+    "$PYTHON" "$PROJECT_ROOT/scripts/lincoln-setup.py" init-repo-config \
+      --root "$PROJECT_ROOT" --owner "$OWNER" --name "$NAME"
+  else
+    echo "   Please ask Claude to run:"
+    echo "     python scripts/lincoln-setup.py init-repo-config --owner <owner> --name <repo>"
+    echo "   Or set LINCOLN_REPO_OWNER and LINCOLN_REPO_NAME and re-run."
+  fi
+else
+  echo "✅ OpenSpec config already contains real values"
+fi
+
+# ---------------------------------------------------------------------------
+# 5. Make validator executable
+# ---------------------------------------------------------------------------
+VALIDATOR="scripts/validate_stage.py"
+if [ -f "$VALIDATOR" ]; then
+  chmod +x "$VALIDATOR"
+  echo "✅ Validator made executable"
+fi
+
+# ---------------------------------------------------------------------------
+# 6. GitHub CLI auth check
+# ---------------------------------------------------------------------------
+if command -v gh > /dev/null 2>&1; then
+  if ! gh auth status > /dev/null 2>&1; then
+    echo "⚠️  GitHub CLI is installed but not authenticated. Ask Claude to run 'gh auth login' before using split-to-github."
+  else
+    echo "✅ GitHub CLI authenticated"
+  fi
+else
+  echo "⚠️  GitHub CLI not found. Ask Claude to install it during bootstrap."
+fi
+
+# ---------------------------------------------------------------------------
+# 7. Initial commit for files created by this script
+# ---------------------------------------------------------------------------
+if [ -z "$(git status --porcelain)" ]; then
+  echo "ℹ️  No changes to commit"
+elif [ -n "$INITIAL_STATUS" ]; then
+  echo "⚠️  Existing local changes detected before initialization; skipping automatic commit."
+  echo "   Review and commit the changes manually when ready."
+else
+  git add \
+    products/.gitkeep \
+    products/README.md \
+    oss/README.md \
+    oss/projects.yaml \
+    knowledge/assets/.gitkeep \
+    knowledge/01-interviews/.gitkeep \
+    knowledge/02-requirements/.gitkeep \
+    knowledge/03-features/.gitkeep \
+    knowledge/04-decisions/.gitkeep \
+    knowledge/06-references/.gitkeep
+  if git diff --cached --quiet; then
+    echo "ℹ️  No tracked initialization changes to commit"
+  else
+    git commit -m "chore: init project with Lincoln workflow"
+    echo "✅ Initial commit created"
+  fi
+fi
+
+# Record that project initialization is complete.
+"$PYTHON" "$PROJECT_ROOT/scripts/lincoln-setup.py" mark-step \
+  --root "$PROJECT_ROOT" --step init_project --status completed
+
+echo ""
+echo "🎉 Lincoln project initialized successfully!"
+echo ""
+echo "Next steps:"
+echo "  1. Create a feature process branch: scripts/init-lincoln-branch.sh --issue-number <number> --session-id <session-id> --design-id <design-id> --process-slug <feature-slug> --push"
+echo "  2. Place interview recordings in <feature-slug>/recordings/"
+echo "  3. Say to Claude Code: '处理一下这个访谈录音 <feature-slug>/recordings/<file>'"

package/framework/scripts/lc-benchmark-cli.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""Explicit CLI entry point for Lincoln benchmark reports (#72).
+
+This wrapper resolves the current workflow state (using the same logic as the
+hooks) and forwards to scripts/lincoln_benchmark.py. It makes `/lc-benchmark`
+a deterministic, opt-in command instead of an implicit side effect of session
+stop or PR events.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+_PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+from scripts import lincoln_benchmark  # noqa: E402
+from scripts.lincoln_paths import resolve_state_path  # noqa: E402
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Generate a Lincoln benchmark report (opt-in)."
+    )
+    parser.add_argument(
+        "--state-file",
+        type=Path,
+        help="Path to workflow-stage.yaml. Auto-resolved if omitted.",
+    )
+    parser.add_argument(
+        "--trigger",
+        choices=["manual", "handoff", "pr_created", "pr_merged", "session_stop"],
+        default="manual",
+        help="Benchmark trigger context (default: manual).",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+
+    state_file = args.state_file
+    if state_file is None:
+        state_file = resolve_state_path(None, _PROJECT_ROOT)
+
+    if not state_file.exists():
+        print(
+            "No Lincoln workflow state found. "
+            "Run this from a repo with an active issue work package.",
+            file=sys.stderr,
+        )
+        return 1
+
+    # Avoid recursive trace logging when benchmark is invoked from a hook.
+    os.environ["LINCOLN_SKIP_TRACE"] = "1"
+    return lincoln_benchmark.main(
+        ["--state-file", str(state_file), "--trigger", args.trigger]
+    )
+
+
+if __name__ == "__main__":
+    sys.exit(main())