lightcone-cli 0.3.3__tar.gz → 0.3.4__tar.gz

{lightcone_cli-0.3.3 → lightcone_cli-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lightcone-cli
-Version: 0.3.3
+Version: 0.3.4
 Summary: Lightcone command-line toolchain
 Author: Lightcone Research
 License: BSD-3-Clause

{lightcone_cli-0.3.3 → lightcone_cli-0.3.4}/claude/lightcone/agents/lc-extractor.md

@@ -2,6 +2,7 @@
 name: lc-extractor
 description: Extract prior insights from scientific papers for ASTRA analyses. Reads PDFs, identifies claims relevant to target decisions, extracts verbatim quotes, and verifies them. Use for literature extraction during /lc-new.
 tools: Read, Bash
+model: sonnet
 ---
 
 You are an ASTRA prior insight extraction agent with self-validation capability. Your task is to extract prior insights from a single paper and format them for an ASTRA analysis. Prior insights are knowledge from literature that informs analysis decisions — they go in the `prior_insights:` section of astra.yaml.

{lightcone_cli-0.3.3 → lightcone_cli-0.3.4}/claude/lightcone/guides/lightcone-cli-reference.md

@@ -20,7 +20,6 @@ The first `lc` invocation auto-creates `~/.lightcone/config.yaml`:
 ```yaml
 container:
   runtime: auto    # or: docker | podman | podman-hpc | none
-# extraction_model: sonnet    # optional; controls the lc-extractor agent
 ```
 
 **Always run via `lc`.** Recipes must execute through `lc run` so that container builds, option resolution, resource limits, and result paths are applied. Treat the underlying execution engine as a black box — never invoke schedulers or container runtimes directly, that will bypass reproducibility guarantees.

lightcone_cli-0.3.4/claude/lightcone/hooks.json

@@ -0,0 +1,30 @@
+{
+  "SessionStart": [
+    {
+      "hooks": [
+        {
+          "type": "command",
+          "command": "bash ${CLAUDE_PROJECT_DIR}/.claude/scripts/activate-venv.sh",
+          "timeout": 5
+        },
+        {
+          "type": "command",
+          "command": "bash ${CLAUDE_PROJECT_DIR}/.claude/scripts/session-start.sh",
+          "timeout": 15
+        }
+      ]
+    }
+  ],
+  "PostToolUse": [
+    {
+      "matcher": "Write|Edit",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "bash ${CLAUDE_PROJECT_DIR}/.claude/scripts/validate-on-save.sh",
+          "timeout": 15
+        }
+      ]
+    }
+  ]
+}

lightcone_cli-0.3.4/claude/lightcone/scripts/activate-venv.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# SessionStart hook: prepend the project venv to PATH for every Bash command
+# Claude Code spawns this session.
+#
+# We don't `source` activate -- we only need PATH and VIRTUAL_ENV. Sourcing
+# activate also runs prompt mutations and defines a deactivate function we
+# don't want, and any non-zero status under `set -e` would silently skip
+# the writeback (the failure mode behind issue #103). Writing the two
+# exports directly to CLAUDE_ENV_FILE is the documented mechanism and is
+# what every downstream hook implicitly relies on for `astra` / `lc` to
+# resolve to the project venv rather than whatever system install happens
+# to be on PATH.
+
+VENV="$CLAUDE_PROJECT_DIR/.venv"
+[ -d "$VENV/bin" ] || exit 0
+[ -n "$CLAUDE_ENV_FILE" ] || exit 0
+
+{
+    echo "export VIRTUAL_ENV=$VENV"
+    echo "export PATH=$VENV/bin:\$PATH"
+} >> "$CLAUDE_ENV_FILE"
+
+exit 0

lightcone_cli-0.3.4/claude/lightcone/scripts/session-start.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+# SessionStart hook: surface a terse project status to the agent.
+#
+# Reports validation status, materialization counts, and pointers to the
+# canonical reference docs. Project name / decision count / universe count
+# are intentionally omitted -- they are trivia the agent reads from
+# astra.yaml and CLAUDE.md when needed, and they cost against the 10k
+# additionalContext budget.
+
+input=$(cat)
+cwd=$(echo "$input" | jq -r '.cwd // empty')
+
+[ -z "$cwd" ] && exit 0
+cd "$cwd" 2>/dev/null || exit 0
+[ -f "astra.yaml" ] || exit 0
+
+# astra and lc both come from the project venv (prepended to PATH by
+# activate-venv.sh). If neither resolved, the venv setup is broken and
+# there is nothing useful we can report.
+command -v astra &>/dev/null || exit 0
+command -v lc &>/dev/null || exit 0
+
+validation_output=$(astra validate astra.yaml 2>&1)
+validation_ok=$?
+
+status_json=$(lc status --json 2>/dev/null)
+counts=$(echo "$status_json" | jq -r '
+    [.universes[].outputs[].status] as $s |
+    {
+        ok: ($s | map(select(. == "ok")) | length),
+        stale: ($s | map(select(. == "stale")) | length),
+        missing: ($s | map(select(. == "missing")) | length),
+        alias: ($s | map(select(. == "alias")) | length)
+    } | "\(.ok) \(.stale) \(.missing) \(.alias)"
+' 2>/dev/null)
+read -r ok_count stale_count missing_count alias_count <<<"$counts"
+ok_count=${ok_count:-0}
+stale_count=${stale_count:-0}
+missing_count=${missing_count:-0}
+alias_count=${alias_count:-0}
+
+if [ "$validation_ok" -eq 0 ]; then
+    summary="ASTRA project — validation: valid"
+else
+    summary="ASTRA project — validation: has errors"
+fi
+
+summary="$summary
+Materialization: ok=$ok_count stale=$stale_count missing=$missing_count alias=$alias_count
+
+References: .claude/guides/astra-reference.md (spec) and .claude/guides/lightcone-cli-reference.md (CLI)."
+
+if [ "$validation_ok" -ne 0 ]; then
+    # tail rather than head -- the leading lines are success markers
+    # ("✓ Schema validation passed" etc.) and the actual error block is
+    # at the bottom.
+    error_preview=$(echo "$validation_output" | tail -20)
+    summary="$summary
+
+Validation errors (run 'astra validate astra.yaml' for full output):
+$error_preview"
+fi
+
+needs_run=$((missing_count + stale_count))
+if [ "$needs_run" -gt 0 ]; then
+    summary="$summary
+
+ACTION REQUIRED: $needs_run output(s) need \`lc run\` ($missing_count missing, $stale_count stale)."
+fi
+
+jq -n --arg ctx "$summary" '{hookSpecificOutput: {hookEventName: "SessionStart", additionalContext: $ctx}}'
+exit 0

lightcone_cli-0.3.4/claude/lightcone/scripts/validate-on-save.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# PostToolUse(Write|Edit) hook: re-validate after writes to astra.yaml or a
+# universe file, push errors back to the agent as additionalContext.
+#
+# astra is resolved from the project venv via PATH (prepended at
+# SessionStart by activate-venv.sh). Issue #103 traced back to this hook
+# running an older, globally-installed astra when activate-venv failed
+# silently -- with the venv reliably on PATH that whole code path is
+# unnecessary.
+
+input=$(cat)
+file_path=$(echo "$input" | jq -r '.tool_input.file_path // .tool_response.filePath // empty')
+[ -z "$file_path" ] && exit 0
+
+filename=$(basename "$file_path")
+parent=$(basename "$(dirname "$file_path")")
+
+# Filter to astra.yaml at any depth and universe files (universes/*.yaml)
+if [ "$filename" = "astra.yaml" ]; then
+    project_root=$(dirname "$file_path")
+elif [ "$parent" = "universes" ] && [[ "$filename" == *.yaml ]]; then
+    project_root=$(dirname "$(dirname "$file_path")")
+else
+    exit 0
+fi
+
+command -v astra &>/dev/null || exit 0
+cd "$project_root" 2>/dev/null || exit 0
+
+if [ "$filename" = "astra.yaml" ]; then
+    result=$(astra validate astra.yaml 2>&1)
+else
+    result=$(astra validate "$file_path" 2>&1)
+fi
+exit_code=$?
+
+if [ $exit_code -eq 0 ]; then
+    msg="ASTRA validation passed for $filename"
+else
+    msg=$(printf 'ASTRA validation FAILED for %s:\n%s' "$filename" "$result")
+fi
+
+jq -n --arg ctx "$msg" '{hookSpecificOutput: {hookEventName: "PostToolUse", additionalContext: $ctx}}'
+exit 0

{lightcone_cli-0.3.3 → lightcone_cli-0.3.4}/claude/lightcone/skills/lc-new/SKILL.md

@@ -68,7 +68,7 @@ For each approved paper: `astra paper add <doi>`, `astra paper path <doi>`, then
 - **Target decisions**: each decision ID, label, and options with descriptions
 - **Timestamp**: current time in ISO 8601
 
-The agent type is pre-configured with the user's preferred extraction model (the `extraction_model` field in `~/.lightcone/config.yaml`). Spawn all in a single message (parallel). Show progress as results come in:
+Spawn all in a single message (parallel). Show progress as results come in:
 
 ```
   ✓ Ba et al. 2016 -- 3 prior insights

{lightcone_cli-0.3.3 → lightcone_cli-0.3.4}/src/lightcone/cli/commands.py

@@ -293,7 +293,12 @@ def _install_claude_plugin(
     plugin_source: Path,
     permissions: str,
 ) -> None:
-    """Copy the bundled Claude Code plugin into the project's ``.claude/``."""
+    """Copy the bundled Claude Code plugin into the project's ``.claude/``.
+
+    The hook configuration ships with the plugin as ``hooks.json`` so
+    that hook entries live next to the scripts they reference. The CLI
+    only owns the ``--permissions`` tier selection.
+    """
     claude_dir = project_dir / ".claude"
     claude_dir.mkdir(exist_ok=True)
     for sub in ("skills", "agents", "hooks", "scripts", "guides", "templates"):
@@ -303,59 +308,14 @@ def _install_claude_plugin(
             if dest.exists():
                 shutil.rmtree(dest)
             shutil.copytree(src, dest)
+    hooks = json.loads((plugin_source / "hooks.json").read_text())
     settings = {
         "permissions": PERMISSION_TIERS[permissions],
-        "hooks": _PROJECT_HOOKS,
+        "hooks": hooks,
     }
     (claude_dir / "settings.json").write_text(json.dumps(settings, indent=2))
 
 
-# Hook entries written into ``<project>/.claude/settings.json``. Scripts are
-# invoked via ``bash`` so a missing +x bit on a contributor's checkout
-# doesn't silently break the hook. Paths use ``${CLAUDE_PROJECT_DIR}`` so
-# the wiring is portable across machines and survives a project move.
-_PROJECT_HOOKS: dict[str, list[dict[str, object]]] = {
-    "SessionStart": [
-        {
-            "hooks": [
-                {
-                    "type": "command",
-                    "command": "bash ${CLAUDE_PROJECT_DIR}/.claude/scripts/activate-venv.sh",
-                    "timeout": 5,
-                },
-                {
-                    "type": "command",
-                    "command": "bash ${CLAUDE_PROJECT_DIR}/.claude/scripts/session-start.sh",
-                    "timeout": 15,
-                },
-            ],
-        },
-    ],
-    "PostToolUse": [
-        {
-            "matcher": "Write|Edit",
-            "hooks": [
-                {
-                    "type": "command",
-                    "command": "bash ${CLAUDE_PROJECT_DIR}/.claude/scripts/validate-on-save.sh",
-                    "timeout": 15,
-                },
-            ],
-        },
-        {
-            "matcher": "Bash",
-            "hooks": [
-                {
-                    "type": "command",
-                    "command": "bash ${CLAUDE_PROJECT_DIR}/.claude/scripts/check-lc-run.sh",
-                    "timeout": 15,
-                },
-            ],
-        },
-    ],
-}
-
-
 # =============================================================================
 # lc run
 # =============================================================================

{lightcone_cli-0.3.3 → lightcone_cli-0.3.4}/src/lightcone/eval/build.py

@@ -78,53 +78,22 @@ def _extract_version(wheel_path: Path) -> str:
     return match.group(1) if match else wheel_path.name
 
 
-def _build_astra_wheel(outdir: Path) -> Path:
-    """Build an ASTRA wheel from the version installed in the current environment.
-
-    Uses importlib.metadata to find the git URL and commit of the installed astra
-    package, then builds a wheel pinned to that exact commit via pip wheel.
-    """
-    import importlib.metadata
-    import json
-
-    dist = importlib.metadata.distribution("astra")
-    url_text = dist.read_text("direct_url.json")
-    if not url_text:
-        raise RuntimeError(
-            "Cannot determine ASTRA source — installed package has no direct_url.json. "
-            "Ensure astra is installed from its git repo (not a plain wheel)."
-        )
-    url_info = json.loads(url_text)
-    git_url = url_info["url"]
-    commit = url_info.get("vcs_info", {}).get("commit_id", "")
-    spec = f"astra @ git+{git_url}@{commit}" if commit else f"astra @ git+{git_url}"
-
-    logger.info("Building ASTRA wheel from %s (commit %s) ...", git_url, commit[:8] or "HEAD")
-    result = subprocess.run(
-        ["pip", "wheel", "--no-deps", "--wheel-dir", str(outdir), spec],
-        capture_output=True, text=True,
-    )
-    if result.returncode != 0:
-        raise RuntimeError(f"ASTRA wheel build failed:\n{result.stderr}")
-
-    wheels = list(outdir.glob("astra-*.whl"))
-    if not wheels:
-        raise RuntimeError(f"No astra wheel found in {outdir} after build")
-    return wheels[0]
-
-
 def build_eval_wheels(evals_dir: Path) -> tuple[VersionInfo, list[Path]]:
-    """Build the lightcone-cli and ASTRA wheels for sandbox injection.
+    """Build the lightcone-cli wheel for sandbox injection.
+
+    Only lightcone-cli is built locally — that's the package under test
+    and must come from the branch's working tree, not from PyPI. ASTRA
+    (``astra-tools`` + ``astra-spec``) is pre-installed in the sandbox
+    image from PyPI alongside the other third-party deps; we record the
+    host's resolved version here for the run report.
 
     Returns (version_info, [wheel_paths]).
-    Both wheels are built fresh from the current environment:
-    - lightcone-cli: built from the local git working tree
-    - ASTRA: built from the git URL/commit recorded in the installed package metadata
     """
+    import importlib.metadata
+
     repo_root = _get_repo_root()
     version_info = _get_git_info(repo_root)
 
-    # Build lightcone-cli wheel into a temp dir
     tmpdir = Path(tempfile.mkdtemp(prefix="lightcone-eval-wheels-"))
     logger.info("Building lightcone-cli wheel from %s ...", repo_root)
     lightcone_wheel = _build_wheel(repo_root, tmpdir)
@@ -134,15 +103,9 @@ def build_eval_wheels(evals_dir: Path) -> tuple[VersionInfo, list[Path]]:
                 version_info.lightcone_commit[:8],
                 " dirty" if version_info.lightcone_dirty else "")
 
-    wheels: list[Path] = [lightcone_wheel]
-
-    # Build ASTRA wheel from the installed package's git source
     try:
-        astra_wheel = _build_astra_wheel(tmpdir)
-        version_info.astra_version = _extract_version(astra_wheel)
-        wheels.append(astra_wheel)
-        logger.info("Built %s", astra_wheel.name)
-    except Exception as exc:
-        logger.warning("Failed to build ASTRA wheel: %s — sandbox may not have astra CLI", exc)
-
-    return version_info, wheels
+        version_info.astra_version = importlib.metadata.version("astra-tools")
+    except importlib.metadata.PackageNotFoundError:
+        pass
+
+    return version_info, [lightcone_wheel]

{lightcone_cli-0.3.3 → lightcone_cli-0.3.4}/src/lightcone/eval/sandbox.py

@@ -71,12 +71,18 @@ class EvalSandbox:
 
         # Build the sandbox image
         if self.sandbox_image is None:
-            # Direct deps from astra + lightcone-cli pyproject.toml (pip resolves transitive).
-            # Kept in sync with the runtime deps declared there — the local astra
-            # and lightcone-cli wheels are uploaded with --no-deps, so anything not
-            # listed here must come from the wheels themselves.
+            # Pre-install third-party Python deps so the only thing we
+            # upload at trial-setup time is the lightcone-cli wheel
+            # built from the branch under test. ``astra-tools`` (which
+            # ships the ``astra`` module) and ``astra-spec`` come from
+            # PyPI here — astra isn't the package under test, just a
+            # dependency, so we let pip resolve like a normal user
+            # install. The lightcone-cli wheel is installed below with
+            # ``--no-deps``, so any runtime dep it relies on must be
+            # listed here.
             deps = (
-                "click httpx jinja2 jsonschema pydantic pypdf pyyaml rapidfuzz rich"
+                "astra-tools astra-spec"
+                " jinja2 jsonschema"
                 " snakemake snakemake-interface-executor-plugins"
                 " snakemake-interface-common dask distributed langfuse"
             )
@@ -156,39 +162,73 @@ class EvalSandbox:
         loop_prompt_template: str,
         wheels: list[Path] | None = None,
     ) -> None:
-        """Upload seed project and template the loop prompt."""
+        """Scaffold the project via ``lc init`` and overlay task seed files.
+
+        The scaffold (``.claude/``, ``CLAUDE.md``, ``Containerfile``,
+        ``requirements.txt``, ``.lightcone/``, ``.gitignore``, default
+        ``universes/baseline.yaml``) is produced by the same ``lc init``
+        command users run — no separate uploaded copies of skills/hooks
+        to drift out of sync. The task seed dir contributes only the
+        bits that ``lc init`` cannot generate: ``astra.yaml``, ``data/``,
+        and ``task.yaml``.
+        """
         assert self._sandbox is not None, "Call create() first"
 
-        # Upload and install dependency wheels
+        # Install dependency wheels system-wide so `lc` and `astra` are
+        # importable before we run them (lc init below, astra universe
+        # generate after the overlay).
         if wheels:
             self._install_wheels(wheels)
 
-        # Upload seed project files
-        self._upload_directory(seed_dir, self.WORK_DIR)
+        # Seed a minimal global config before invoking `lc`. `lc`'s main
+        # group would auto-create this, but writing it explicitly pins
+        # the runtime for reproducibility across eval runs.
+        self.exec(
+            "mkdir -p ~/.lightcone"
+            " && printf 'container:\\n  runtime: auto\\n' > ~/.lightcone/config.yaml"
+        )
 
-        # Template the loop prompt
-        prompt = loop_prompt_template.replace("{{UNIVERSE}}", universe)
-        self.upload_file("/tmp/loop-prompt.md", prompt.encode())
+        # Scaffold the project using the lc init from the wheel under
+        # test. --no-venv: deps are pre-installed system-wide on the
+        # sandbox image. --no-git: we run git init below, after the
+        # overlay, so the seed commit captures the task files too.
+        result = self.exec(
+            f"mkdir -p {self.WORK_DIR}"
+            f" && lc init {self.WORK_DIR} --no-git --no-venv",
+            timeout=120,
+        )
+        if result.exit_code != 0:
+            raise RuntimeError(
+                f"`lc init` failed (exit {result.exit_code}):\n"
+                f"{result.output[-2000:]}"
+            )
 
-        # Upload lightcone-cli plugin files (.claude/ with skills, hooks, scripts, agents)
-        # We can't use `lc init` because the seed project already has astra.yaml,
-        # and lc init refuses to run in that case. Instead, upload directly.
-        self._install_claude_plugins()
+        # Overlay task seed files (astra.yaml, data/, task.yaml). The
+        # task's astra.yaml replaces the one `astra init` boilerplated.
+        self._upload_directory(seed_dir, self.WORK_DIR)
 
-        # Seed a minimal global config. The `lc` main group would auto-create
-        # this on first invocation, but we write it explicitly so the runtime
-        # is pinned for reproducibility across eval runs.
+        # Regenerate baseline.yaml from the task astra.yaml's defaults.
+        # The one lc init produced matches the boilerplate astra.yaml
+        # (different decisions), so it would no longer be coherent.
         self.exec(
-            "mkdir -p ~/.lightcone"
-            " && printf 'container:\\n  runtime: auto\\n' > ~/.lightcone/config.yaml"
+            f"cd {self.WORK_DIR}"
+            f" && rm -f universes/baseline.yaml"
+            f" && astra universe generate -n baseline"
+            f" -d 'Default configuration using standard practices'",
+            timeout=60,
         )
 
-        # Git init (exec runs as evaluser via Dockerfile USER directive)
+        # Template and stage the loop prompt for the agent.
+        prompt = loop_prompt_template.replace("{{UNIVERSE}}", universe)
+        self.upload_file("/tmp/loop-prompt.md", prompt.encode())
+
+        # Initial commit captures the full project state (scaffold +
+        # task overlay + regenerated universe).
         self.exec(
             f"cd {self.WORK_DIR}"
             " && git config --global user.name Eval"
             " && git config --global user.email eval@lightcone"
-            " && git init && git add -A && git commit -m 'seed'"
+            " && git init -q && git add -A && git commit -q -m 'seed'"
         )
 
     def exec(self, cmd: str, timeout: int = 300, cwd: str | None = None) -> ExecuteResult:
@@ -290,48 +330,14 @@ class EvalSandbox:
                 )
             self._sandbox = None
 
-    def _install_claude_plugins(self) -> None:
-        """Upload lightcone-cli's Claude Code plugin files (skills, hooks, scripts, agents)."""
-        from lightcone.cli.plugin import get_plugin_source_dir
-
-        plugin_source = get_plugin_source_dir()
-        if plugin_source is None:
-            logger.warning("Could not find lightcone-cli plugin source files — skipping")
-            return
-
-        claude_dir = f"{self.WORK_DIR}/.claude"
-
-        # Upload plugin subdirectories
-        for subdir in ("skills", "hooks", "scripts", "agents"):
-            src = plugin_source / subdir
-            if src.exists():
-                self._upload_directory(src, f"{claude_dir}/{subdir}")
-
-        # Upload CLAUDE.md template as project CLAUDE.md if not already present
-        template = plugin_source / "templates" / "CLAUDE.md"
-        if template.exists():
-            self.upload_file(f"{self.WORK_DIR}/CLAUDE.md", template.read_bytes())
-
-        # Make scripts executable
-        self.exec(
-            f"chmod -R +x {claude_dir}/scripts/ {claude_dir}/hooks/ 2>/dev/null || true"
-        )
-
-        # Create minimal settings.json (bypassPermissions, no hooks that need
-        # absolute paths or venvs — the eval sandbox is ephemeral)
-        settings = json.dumps({
-            "permissions": {"allow": ["Bash", "Read", "Edit", "Write", "WebSearch", "WebFetch"]},
-        })
-        self.upload_file(
-            f"{claude_dir}/settings.json",
-            settings.encode(),
-        )
-
     def _install_wheels(self, wheels: list[Path]) -> None:
-        """Upload and install wheel files into the sandbox.
+        """Upload and install the lightcone-cli wheel into the sandbox.
 
-        Third-party deps are pre-installed in the sandbox image.
-        Only the local astra/lightcone-cli wheels need to be uploaded and installed here.
+        The wheel is built from the branch under test in
+        :func:`lightcone.eval.build.build_eval_wheels`. ``--no-deps``
+        because every runtime dep is already in the sandbox image;
+        ``--force-reinstall`` so the local wheel always overrides any
+        pre-existing install and we never silently run a PyPI version.
         """
         self.exec("mkdir -p /tmp/deps")
 
@@ -341,7 +347,10 @@ class EvalSandbox:
             self.upload_file(remote_path, whl.read_bytes())
             remote_paths.append(remote_path)
 
-        whl_cmd = "pip install --no-deps " + " ".join(shlex.quote(p) for p in remote_paths)
+        whl_cmd = (
+            "pip install --no-deps --force-reinstall "
+            + " ".join(shlex.quote(p) for p in remote_paths)
+        )
         result = self.exec(whl_cmd, timeout=120)
         if result.exit_code != 0:
             logger.warning(

lightcone_cli-0.3.3/claude/lightcone/scripts/activate-venv.sh

@@ -1,44 +0,0 @@
-#!/bin/bash
-# Activate Python virtual environment if it exists in the project directory
-# This hook runs at SessionStart to ensure the venv is active for Claude Code
-
-set -e
-
-# Check if we have a project directory
-if [ -z "$CLAUDE_PROJECT_DIR" ]; then
-    exit 0
-fi
-
-# Check for .venv in project directory
-VENV_DIR="$CLAUDE_PROJECT_DIR/.venv"
-if [ ! -d "$VENV_DIR" ]; then
-    exit 0
-fi
-
-# Determine activate script path based on OS
-if [ -f "$VENV_DIR/bin/activate" ]; then
-    ACTIVATE_SCRIPT="$VENV_DIR/bin/activate"
-elif [ -f "$VENV_DIR/Scripts/activate" ]; then
-    ACTIVATE_SCRIPT="$VENV_DIR/Scripts/activate"
-else
-    exit 0
-fi
-
-# Capture environment before activation
-BEFORE_PATH="$PATH"
-BEFORE_VIRTUAL_ENV="${VIRTUAL_ENV:-}"
-
-# Source the activation script
-# shellcheck source=/dev/null
-source "$ACTIVATE_SCRIPT"
-
-# If CLAUDE_ENV_FILE is set, write environment changes to it
-if [ -n "$CLAUDE_ENV_FILE" ]; then
-    # Write PATH update
-    echo "PATH=$PATH" >> "$CLAUDE_ENV_FILE"
-
-    # Write VIRTUAL_ENV
-    echo "VIRTUAL_ENV=$VIRTUAL_ENV" >> "$CLAUDE_ENV_FILE"
-fi
-
-exit 0

lightcone_cli-0.3.3/claude/lightcone/scripts/check-lc-run.sh

@@ -1,107 +0,0 @@
-#!/bin/bash
-# PostToolUse hook: warn when the agent runs a Python script that has an
-# integrated recipe — they should use `lc run` so a manifest gets written.
-#
-# Pure bash + jq + the `lc` binary on PATH. No Python imports — the hook
-# previously imported `lightcone.engine.status` which silently failed in
-# the empty venv `lc init` creates, so the hook was a no-op for nearly
-# every project. Status data now comes from `lc status --json`, which
-# carries the recipe template per output as of the same change.
-
-input=$(cat)
-command=$(echo "$input" | jq -r '.tool_input.command // empty')
-
-[ -z "$command" ] && exit 0
-
-# Only inspect commands that contain "python" / "python3"
-echo "$command" | grep -qE 'python[23]?[[:space:]]' || exit 0
-
-# Skip lc/astra invocations (they're already going through the right path)
-echo "$command" | grep -qE '(^|[[:space:]/])(lc|astra)[[:space:]]' && exit 0
-
-# Must be in an ASTRA project
-[ -f "astra.yaml" ] || exit 0
-
-# Must have lc on PATH; otherwise we can't get status
-command -v lc &> /dev/null || exit 0
-
-# Parse --universe NAME or --universe=NAME from the agent's command;
-# default to baseline.
-universe=$(echo "$command" \
-  | grep -oE -- '--universe[= ][[:space:]]*[^[:space:]]+' \
-  | head -1 \
-  | sed -E 's/--universe[= ][[:space:]]*//')
-[ -z "$universe" ] && universe="baseline"
-
-status_json=$(lc status --json --universe "$universe" 2>/dev/null) || exit 0
-
-# Collect script paths the agent invoked. Split on && || ; first so each
-# chained command is considered separately, then look for tokens ending
-# in .py and `python -m module.path`.
-agent_scripts=$(echo "$command" | awk '
-{
-    # Split on shell separators
-    gsub(/&&|\|\||;/, "\n")
-    print
-}' | awk '
-{
-    n = split($0, tok, /[[:space:]]+/)
-    for (i = 1; i <= n; i++) {
-        t = tok[i]
-        if (t ~ /\.py$/) {
-            sub(/^\.\//, "", t)
-            print t
-            n2 = split(t, pp, "/")
-            print pp[n2]
-        }
-        if (t == "-m" && i + 1 <= n) {
-            mod = tok[i+1]
-            gsub(/\./, "/", mod)
-            print mod ".py"
-            n2 = split(mod, pp, "/")
-            print pp[n2] ".py"
-        }
-    }
-}' | sort -u)
-
-[ -z "$agent_scripts" ] && exit 0
-
-# For each output that has a recipe, extract the script path from the
-# recipe template and check whether the agent's command invoked it.
-matched=$(echo "$status_json" | jq -r --arg uni "$universe" '
-    .universes[]
-    | select(.universe_id == $uni)
-    | .outputs[]
-    | select(.recipe_command != null and .recipe_command != "")
-    | "\(.output_id)\t\(.status)\t\(.recipe_command)"
-' | while IFS=$'\t' read -r out_id out_status recipe_cmd; do
-    recipe_scripts=$(echo "$recipe_cmd" | tr ' \t\n' '\n' | grep '\.py$' | sed 's|^\./||')
-    for r in $recipe_scripts; do
-        rb=$(basename "$r")
-        if echo "$agent_scripts" | grep -qFx "$r" || echo "$agent_scripts" | grep -qFx "$rb"; then
-            printf '%s\t%s\n' "$out_id" "$out_status"
-            break
-        fi
-    done
-done | head -1)
-
-[ -z "$matched" ] && exit 0
-
-matched_id=$(echo "$matched" | cut -f1)
-matched_status=$(echo "$matched" | cut -f2)
-
-case "$matched_status" in
-    missing|stale)
-        msg="WARNING: You ran the script for output \`$matched_id\` directly (status: $matched_status in $universe), which has an integrated recipe. Use \`lc run $matched_id --universe $universe\` instead so a manifest is written and the result is reproducible."
-        ;;
-    ok)
-        msg="NOTE: Output \`$matched_id\` already has current results in $universe from \`lc run\`. Running the script directly bypasses the manifest — use \`lc run $matched_id --universe $universe\` to regenerate reproducibly."
-        ;;
-    *)
-        exit 0
-        ;;
-esac
-
-escaped_msg=$(echo "$msg" | jq -Rs .)
-echo "{\"hookSpecificOutput\": {\"hookEventName\": \"PostToolUse\", \"additionalContext\": $escaped_msg}}"
-exit 0

lightcone_cli-0.3.3/claude/lightcone/scripts/session-start.sh

@@ -1,120 +0,0 @@
-#!/bin/bash
-# SessionStart hook: Show ASTRA analysis summary when entering a project
-# Provides context about the current analysis state
-
-# Read JSON input from stdin
-input=$(cat)
-
-# Get the current working directory
-cwd=$(echo "$input" | jq -r '.cwd // empty')
-
-if [ -z "$cwd" ]; then
-    exit 0
-fi
-
-cd "$cwd" 2>/dev/null || exit 0
-
-# Sync extraction model from ~/.lightcone/config.yaml to .claude/agents/lc-extractor.md
-if [ -f ".claude/agents/lc-extractor.md" ] && [ -f "$HOME/.lightcone/config.yaml" ]; then
-    ext_model=$(grep '^extraction_model:' "$HOME/.lightcone/config.yaml" 2>/dev/null | awk '{print $2}' | tr -d "'\"")
-    # Default to sonnet if not configured
-    [ -z "$ext_model" ] && ext_model="sonnet"
-    if [ -n "$ext_model" ]; then
-        if ! grep -q "^model:" .claude/agents/lc-extractor.md 2>/dev/null; then
-            # Insert model field after description line
-            sed -i.bak '/^tools:/i\
-model: '"$ext_model" .claude/agents/lc-extractor.md 2>/dev/null && rm -f .claude/agents/lc-extractor.md.bak
-        else
-            # Update existing model field
-            sed -i.bak 's/^model: .*/model: '"$ext_model"'/' .claude/agents/lc-extractor.md 2>/dev/null && rm -f .claude/agents/lc-extractor.md.bak
-        fi
-    else
-        # Empty model = inherit, remove model line if present
-        sed -i.bak '/^model: /d' .claude/agents/lc-extractor.md 2>/dev/null && rm -f .claude/agents/lc-extractor.md.bak
-    fi
-fi
-
-# Check if this is an ASTRA project (has astra.yaml)
-if [ ! -f "astra.yaml" ]; then
-    exit 0
-fi
-
-# Check if astra command is available
-if ! command -v astra &> /dev/null; then
-    # Provide minimal info without CLI
-    echo "{\"hookSpecificOutput\": {\"hookEventName\": \"SessionStart\", \"additionalContext\": \"This is an ASTRA project. The astra CLI is not installed - run 'pip install astra' to enable validation and other commands.\"}}"
-    exit 0
-fi
-
-# Gather analysis information. `astra init` writes `name:` at the top
-# level (no indent); previous indented form was pre-asset-centric.
-# Use -E (ERE) so `?` works on both BSD and GNU sed.
-analysis_name=$(grep -m1 "^name:" astra.yaml 2>/dev/null | sed -E 's/^name:[[:space:]]*"?([^"]*)"?[[:space:]]*$/\1/')
-
-# Count keys under 'decisions:' (block-form decisions only)
-decision_count=$(awk '/^decisions:/{found=1; next} found && /^  [a-z_]+:/{count++} found && /^[a-z]/{exit} END{print count}' astra.yaml 2>/dev/null)
-
-# Count universes
-universe_count=$(ls -1 universes/*.yaml 2>/dev/null | wc -l | tr -d ' ')
-
-# Check validation status
-validation_result=$(astra validate astra.yaml 2>&1)
-if [ $? -eq 0 ]; then
-    validation_status="valid"
-else
-    validation_status="has errors"
-fi
-
-# Build summary
-summary="ASTRA Project: ${analysis_name:-unnamed}
-- Decisions: ${decision_count:-0}
-- Universes: ${universe_count:-0}
-- Validation: ${validation_status}
-- Reference: For astra.yaml syntax and spec format, read .claude/guides/astra-reference.md; for CLI and execution, read .claude/guides/lightcone-cli-reference.md"
-
-# If validation failed, add error summary. We prefer the tail because the
-# leading lines are the success header (`✓ Schema validation passed` etc.)
-# and the actual error block is at the bottom. `head -5` historically hid
-# every real error.
-if [ "$validation_status" = "has errors" ]; then
-    error_preview=$(echo "$validation_result" | tail -20)
-    summary="$summary
-
-Validation errors (run 'astra validate astra.yaml' for full output):
-$error_preview"
-fi
-
-# Add lc status if lc CLI is available. States are 'ok' / 'stale' /
-# 'missing' / 'alias' (manifest-driven). The output uses Rich glyphs:
-# '✓ ok', '✸ stale', '✗ miss', '→ alias'.
-if command -v lc &> /dev/null; then
-    lc_status=$(lc status 2>&1)
-    lc_exit=$?
-    if [ $lc_exit -eq 0 ]; then
-        ok_count=$(echo "$lc_status" | grep -c "✓ ok")
-        stale_count=$(echo "$lc_status" | grep -c "✸ stale")
-        missing_count=$(echo "$lc_status" | grep -c "✗ miss")
-        alias_count=$(echo "$lc_status" | grep -c "→ alias")
-
-        summary="$summary
-
-Materialization status:
-- ok: ${ok_count}
-- stale: ${stale_count}
-- missing: ${missing_count}
-- alias: ${alias_count}"
-
-        needs_run=$((missing_count + stale_count))
-        if [ "$needs_run" -gt 0 ]; then
-            summary="$summary
-
-ACTION REQUIRED: ${needs_run} output(s) need \`lc run\` (${missing_count} missing, ${stale_count} stale)."
-        fi
-    fi
-fi
-
-# Output as JSON
-escaped_summary=$(echo "$summary" | jq -Rs .)
-echo "{\"hookSpecificOutput\": {\"hookEventName\": \"SessionStart\", \"additionalContext\": $escaped_summary}}"
-
-exit 0

lightcone_cli-0.3.3/claude/lightcone/scripts/validate-on-save.sh

@@ -1,77 +0,0 @@
-#!/bin/bash
-# PostToolUse hook: Auto-validate ASTRA files after modification
-# Triggers on Write|Edit of astra.yaml or universes/*.yaml
-
-# Read JSON input from stdin
-input=$(cat)
-
-# Extract the file path that was modified
-file_path=$(echo "$input" | jq -r '.tool_input.file_path // .tool_response.filePath // empty')
-
-# Exit silently if no file path
-if [ -z "$file_path" ]; then
-    exit 0
-fi
-
-# Get the filename
-filename=$(basename "$file_path")
-dirpath=$(dirname "$file_path")
-dirname=$(basename "$dirpath")
-
-# Check if this is an ASTRA-related file
-is_astra_file=false
-
-# Check for astra.yaml (main analysis file)
-if [ "$filename" = "astra.yaml" ]; then
-    is_astra_file=true
-    file_type="analysis"
-fi
-
-# Check for universe files (in universes/ directory)
-if [ "$dirname" = "universes" ] && [[ "$filename" == *.yaml ]]; then
-    is_astra_file=true
-    file_type="universe"
-fi
-
-# Exit if not an ASTRA file
-if [ "$is_astra_file" = false ]; then
-    exit 0
-fi
-
-# Find the project root (where astra.yaml lives)
-if [ "$file_type" = "analysis" ]; then
-    project_root="$dirpath"
-else
-    # For universe files, go up one level
-    project_root=$(dirname "$dirpath")
-fi
-
-# Check if astra command is available
-if ! command -v astra &> /dev/null; then
-    # ASTRA CLI not installed, skip validation
-    exit 0
-fi
-
-# Run validation
-cd "$project_root" 2>/dev/null || exit 0
-
-if [ "$file_type" = "analysis" ]; then
-    result=$(astra validate astra.yaml 2>&1)
-    exit_code=$?
-else
-    result=$(astra validate "$file_path" 2>&1)
-    exit_code=$?
-fi
-
-# Prepare response
-if [ $exit_code -eq 0 ]; then
-    # Validation passed
-    echo "{\"hookSpecificOutput\": {\"hookEventName\": \"PostToolUse\", \"additionalContext\": \"ASTRA validation passed for $filename\"}}"
-else
-    # Validation failed - provide context to Claude
-    # Escape the result for JSON (jq -Rs . adds quotes, so use it directly)
-    escaped_result=$(echo "ASTRA validation FAILED for $filename:\n$result" | jq -Rs .)
-    echo "{\"hookSpecificOutput\": {\"hookEventName\": \"PostToolUse\", \"additionalContext\": $escaped_result}}"
-fi
-
-exit 0