argus-reviewer-e2e 0.2.0 → 0.3.0

package/README.md

@@ -1,4 +1,4 @@
-# argus-reviewer
+# Argus
 
 <p align="center">
   <img src="docs/assets/social.png" alt="Argus — vision-model E2E testing" width="640" />
@@ -11,95 +11,108 @@
   <a href="https://github.com/duketopceo/Argus/security/policy"><img src="https://img.shields.io/badge/security-policy-orange" alt="security policy" /></a>
 </p>
 
-Open-source, self-hosted vision-model E2E testing — the hundred-eyed watcher for your UI. Bring your own `OPENROUTER_API_KEY`: record a flow once, fingerprint-cache every step, replay near-free, heal on UI drift, and get results as a check + comment on the GitHub PR.
+**The hundred-eyed watcher for your pull requests.** Argus reviews your diff, then goes further: it starts your real app, clicks through it like a user, and executes probes against suspected bugs — then posts a verdict on the PR with the exact dollar cost. Self-hosted, MIT-licensed, bring-your-own OpenRouter key. No SaaS middleman, no telemetry, no per-seat pricing.
 
-- **Vision-first**: a model looks at a screenshot and decides where to click — no selectors to write or maintain.
-- **Cache-first**: replay costs zero vision calls on an unchanged UI; heals re-spend only on drift and show up as reviewable cache diffs.
-- **Cost-explicit**: every call is metered from OpenRouter's per-call cost and rolled into a per-run dollar figure on the PR.
-- **Grounding specialist**: a `grounding_model` (e.g. a ui-tars-class model) can drive element location with its native coordinate output, verified against the DOM before any click executes.
-- **Execution-backed review**: `code-review` findings carry CI evidence, and with the opt-in sandbox lane (`sandbox: { enabled: true }`) Argus authors a test probe for unexercised findings and runs it in a hardened, network-less Docker container — a finding that fails on head and passes on base is stamped **reproduced**, not just suspected.
+## Get started in 60 seconds
 
 ```bash
-npm i -D argus-reviewer-e2e        # or github:duketopceo/argus-reviewer
-npx argus-reviewer record "log in and open settings" --url https://localhost:3000
-npx argus-reviewer run             # replays + asserts, zero-cost on cache hit
+npm i -D argus-reviewer-e2e      # the npm package; the command it installs is `argus-reviewer`
+npx argus-reviewer init          # writes config + smoke test + GitHub workflow
 ```
 
+Add `OPENROUTER_API_KEY` to your environment (and repo secrets for CI). Then:
+
+```bash
+npx argus-reviewer record "sign in and open the dashboard" --url http://localhost:3000
+npx argus-reviewer run           # replays + asserts — free on cache hit
+```
+
+That's it. `init` drops a ready-to-run GitHub workflow; every PR from then on gets a review comment with findings, flow results, video evidence, and spend.
+
+## What lands on your PR
+
+A sticky comment that updates on every push:
+
+- **Verdict** — `APPROVE` / `NEEDS_CHANGES` with findings linked to concrete source lines
+- **Inline comments on every severity** — one batched PR review, severity-sorted; each finding can carry a committable `suggestion` block you apply in one click
+- **Blocks only on proof** — the review escalates to `REQUEST_CHANGES` only for reproduced or adjudicated blockers; everything else stays advisory. Stale request-changes reviews are dismissed automatically, and `requestChanges: false` keeps it advisory forever
+- **Flow results** — which recorded user-journeys passed, healed, or broke
+- **Reproduced, not suspected** — opt-in sandbox lane runs authored regression probes; a probe that fails on head and passes on base stamps the finding as *proven*
+- **Cost** — every model call metered from OpenRouter's per-call pricing, totaled in dollars
+
+That comment is **not a review**. `require_approving_reviews` reads reviews only, so on a protected branch the verdict alone leaves the gate unsatisfied. Supply `approval-token` — a GitHub App installation token, or a PAT from an account that is not the PR author — and Argus also submits a real review whose event follows the verdict. `github.token` cannot do this; GitHub refuses it outright. A token alone is **not** enough: an `APPROVE` also needs `approval-evidence` naming the test command, and `approval-check` naming a check run that has completed green on the pull request's head commit, produced by the App named in `approval-check-app` (`github-actions` by default). Details, the measured refusals, and the review-discipline rules: [`docs/approval-token.md`](docs/approval-token.md).
+
 <p align="center">
   <img src="docs/assets/demo.gif" alt="argus-reviewer run — live vision call, PASS, $0.0005 spend" width="900" />
 </p>
 
-*Real `run` output: one vision assert, `PASS`, and the exact dollar figure on the run report.*
+## Why it's different
 
-Configuration lives in `argus-reviewer.config.ts` (a legacy `vision-e2e.config.*` is still accepted) — see `src/config.ts` for the full shape: `model`, `grounding_model`, `escalation_model`, `provider` routing rules, `budgetUsd`, `target`, `pageSetup`, `secrets`.
+| | Argus |
+|---|---|
+| **Selectors** | None. A vision model looks at a screenshot and decides where to click. |
+| **Maintenance** | Fingerprint cache replays at zero model cost; when the UI drifts, self-healing re-grounds and the heal shows up as a reviewable diff. |
+| **Review depth** | Beyond the diff: full-source evidence linkage, CI evidence, executed probes, real browser runs. |
+| **Spend** | You pick the models per lane (`model`, `grounding_model`, `code_model`, `escalation_model`) and set `budgetUsd`. Cache hits cost nothing. |
+| **Data** | Yours. Keys, journals, videos, and reports stay on your infra. |
 
-### OpenRouter cost attribution
+## Configuration
 
-Add an `openrouter` block to tag every request. `trace` is sent in the request body and is the right hook for cost allocation by repo/PR/run. `headers` are sent verbatim with every OpenRouter request (useful for `HTTP-Referer` or `X-Title`).
+`argus-reviewer.config.ts`:
 
 ```ts
-export default {
-  openrouter: {
-    trace: { repo: 'duketopceo/myapp', pr: '42', run: 'argus-reviewer' },
-    headers: { 'HTTP-Referer': 'https://github.com/duketopceo/myapp' },
-  },
-}
+import { defineConfig } from 'argus-reviewer-e2e'
+
+export default defineConfig({
+  model: 'google/gemini-2.5-flash-lite',          // vision grounding + actions
+  code_model: 'deepseek/deepseek-v4.1-flash',     // diff review
+  escalation_model: 'anthropic/claude-sonnet-4',  // risky/complex findings
+  budgetUsd: 1.0,
+  target: { url: 'https://your-app.example.com' },
+  testsDir: 'e2e',
+})
 ```
 
-The GitHub Action automatically sets `ARGUS_REVIEWER_TRACE` with the repository, PR number, commit, and run id, so every PR review is attributed in OpenRouter without extra config. You can also set `ARGUS_REVIEWER_TRACE` yourself (JSON object) to add more fields.
+Point `provider.order` at fast OpenRouter backends (`cerebras`, `groq`) for sub-second review calls — speed is a routing choice, not a pricing tier. Full shape: [`src/config.ts`](src/config.ts) (a legacy `vision-e2e.config.*` is still accepted). Setup walkthrough: [`docs/quickstart.md`](docs/quickstart.md).
+
+## The execution ladder
+
+Argus does more as you grant it more access — each rung is opt-in:
+
+1. **API review** — GitHub token only. Reviews the PR diff and posts the verdict.
+2. **Trusted checkout** — findings get verified against the full source tree.
+3. **Browser flows** — Playwright drives your real app through recorded journeys.
+4. **Sandbox probes** — suspected findings get authored regression tests, executed in a hardened container (no network, no secrets, read-only FS). Fork PRs stay behind an `argus-probe` label gate.
+5. **Agent Zero delegation** — `argus-reviewer delegate "find the checkout bug"` hands exploratory work to your own A0 instance.
+
+## Cost attribution
+
+Every OpenRouter call carries a trace tag. The action auto-sets `ARGUS_REVIEWER_TRACE` (repo, PR, commit, run id) so spend is attributable per review — or set it yourself for custom fields. See [`docs/quickstart.md`](docs/quickstart.md) for the `openrouter` config block.
+
+## Security model
 
-Status: early development. See `action/` for the composite GitHub Action,
-`runner/` for self-hosted runner registration, `docs/quickstart.md` for
-setup, `SECURITY.md` for the threat model, and `CONTRIBUTING.md` to hack
-on it.
+Reviews run against hostile input by design: untrusted checkouts never execute config code, fork PRs are label-gated, secrets are filtered from model context and comment output, and the sandbox probe lane runs network-less with a read-only filesystem. Threat model: [`SECURITY.md`](SECURITY.md).
 
 ## File structure
 
 ```text
 argus-reviewer/
 ├── action/                  # GitHub Actions composite action + sticky PR comment
-│   ├── action.yml
-│   └── sticky-comment.mjs
 ├── runner/                  # Self-hosted runner registration docs + script
-│   ├── README.md
-│   └── register-runner.sh
 ├── electron/                # Local observability dashboard (`npm run app`)
 ├── src/
-│   ├── api.ts               # Test-facing `test`/`td` API + generated test file renderer
+│   ├── api.ts               # Test-facing `test`/`td` API + generated test renderer
 │   ├── cli.ts               # record · run · code-review · delegate · cache · index · init
-│   ├── config.ts            # `argus-reviewer.config.*` loader (legacy `vision-e2e.config.*` accepted)
-│   ├── cache/
-│   │   ├── fingerprint.ts   # Per-step screenshot/a11y fingerprint + resolve
-│   │   └── store.ts         # Flow cache read/write
-│   ├── driver/
-│   │   ├── browser.ts       # Playwright browser launch (chromium/firefox/webkit) + observation capture
-│   │   └── target.ts        # Optional local dev-server target process
-│   ├── engine/
-│   │   ├── actions.ts       # Low-level page actions (click, type, scroll, …)
-│   │   ├── loop.ts          # Vision model record/replay + healing loop
-│   │   └── prompts.ts       # OpenRouter action/assertion prompts + JSON schemas
-│   ├── evidence/
-│   │   ├── ci.ts            # PR metadata + CI check-run context for findings
-│   │   ├── gate.ts          # Fork-PR trust gate (argus-probe label bound to head SHA)
-│   │   └── link.ts          # Finding → evidence linkage + comment-safe sanitization
-│   ├── executor/
-│   │   ├── a0.ts            # `a0 headless -p` delegation to a user's Agent Zero instance
-│   │   └── sandbox.ts       # Hardened Docker runner for generated probes
-│   ├── index/               # Repo index, diff context, cache invalidation
-│   ├── journal/             # Per-run structured journal entries
-│   ├── probe/
-│   │   ├── author.ts        # Model-authored regression probe generation + validation
-│   │   ├── harness.ts       # vitest/jest/node:test detection + TAP classification
-│   │   └── queue.ts         # Head-vs-merge-base probe orchestration
-│   ├── report/
-│   │   ├── comment.ts       # Markdown PR comment + commit-status rendering
-│   │   ├── junit.ts         # JUnit XML output
-│   │   └── run.ts           # JSON run report consumed by the action
-│   └── vision/
-│       ├── cost.ts          # OpenRouter cost parsing per call
-│       ├── ledger.ts        # Per-run USD budget tracking
-│       └── openrouter.ts    # OpenRouter chat-completion client + schema parsing
-└── tests/                   # Unit tests + small Playwright fixture page
+│   ├── config.ts            # `argus-reviewer.config.*` loader
+│   ├── cache/               # Per-step fingerprint + flow store
+│   ├── driver/              # Playwright browser + dev-server target
+│   ├── engine/              # Vision record/replay + healing loop
+│   ├── evidence/            # PR/CI context, fork trust gate, finding linkage
+│   ├── executor/            # Agent Zero delegation + hardened probe sandbox
+│   ├── probe/               # Model-authored regression probes
+│   ├── report/              # PR comment, JUnit XML, run.json
+│   └── vision/              # OpenRouter client, cost parsing, budget ledger
+└── tests/                   # Unit tests + Playwright fixture page
 ```
 
-License: MIT.
+License: [MIT](LICENSE).

package/action/action.yml

@@ -5,9 +5,13 @@ inputs:
   openrouter-api-key:
     description: OpenRouter API key (BYOK). All vision calls are billed through this key.
     required: true
+  argus-version:
+    description: Optional pinned argus-reviewer-e2e npm version. Empty installs the CLI package from this action ref with lifecycle scripts disabled.
+    default: ''
+    required: false
   cli:
-    description: Command used to run argus-reviewer (defaults to `npx --no-install argus-reviewer`). For dogfooding this repo, use `node dist/cli.js` after `npm run build`.
-    default: npx --no-install argus-reviewer
+    description: Optional executable plus arguments for a trusted local CLI override. Shell operators are rejected; empty installs the CLI package from this action ref.
+    default: ''
     required: false
   config:
     description: Path to the argus-reviewer config file
@@ -35,11 +39,8 @@ inputs:
     description: Playwright browser engine to install and run (chromium, firefox, or webkit). Should match config.browser.
     default: 'chromium'
     required: false
-  cache-dependency-path:
-    description: npm lockfile path for setup-node cache (defaults to <working-directory>/package-lock.json)
-    required: false
   report-dir:
-    description: Report output dir, passed to both run and code-review so the post step can find run.json/code-review.json regardless of config reportDir
+    description: Report output dir, passed to both run and code-review so the post step can find artifacts
     default: argus-reviewer-report
     required: false
   sandbox:
@@ -50,109 +51,174 @@ inputs:
     description: Cap on inline review comments posted per run; overflow is summarized in the sticky. Overrides review.maxComments when set.
     default: ''
     required: false
+  install-consumer-dependencies:
+    description: Explicitly install the consumer project's dependencies for a trusted runtime lane. Disabled by default so code review never runs PR-controlled lifecycle scripts beside secrets.
+    default: 'false'
+    required: false
   run:
-    description: Run the browser-flow lane (`argus-reviewer run`). Set 'false' for code-review-only consumers — repos without a per-PR web target (CLIs, libraries, infra repos). Skips the Playwright install and run steps; the sticky comment and commit status then reflect code-review alone.
+    description: Run the browser-flow lane (`argus-reviewer run`). Disabled by default for public code-review-only repositories. Requires an explicit target and a trusted runtime path.
+    default: 'false'
+    required: false
+  approval-token:
+    description: >-
+      Optional token that lets Argus submit a *formal* pull request review, which
+      is what `require_approving_reviews` reads. `github.token` cannot be used:
+      GitHub refuses it with 422 "GitHub Actions is not permitted to approve
+      pull requests", and no permission scope changes that. Supply a GitHub App
+      installation token, or a PAT belonging to an account that is not the PR
+      author. Empty (the default) keeps Argus to the sticky comment only. See
+      docs/approval-token.md.
+    default: ''
+    required: false
+  approval-evidence:
+    description: >-
+      The test command(s) an approval stands on, cited verbatim in the review
+      body — e.g. 'python -m unittest discover -s tests && ruff check .'.
+      Required whenever approval-token is supplied: the lane refuses to submit
+      an approval that cites no command, so an approver is always re-runnable.
+      Ignored when approval-token is empty.
+    default: ''
+    required: false
+  approval-check:
+    description: >-
+      Name of a check run that must have completed successfully on the head
+      commit before Argus will submit an APPROVE, e.g. 'test (22)' or 'lint'.
+      This is what makes the cited test command evidence rather than a claim:
+      the review cites the real run. An APPROVE with no green run of this name
+      is refused. Ignored on the REQUEST_CHANGES and COMMENT paths, so a
+      negative review still goes out while CI is red.
+    default: ''
+    required: false
+  approval-check-app:
+    description: >-
+      App slug that is allowed to produce the approval-check run, e.g.
+      'github-actions'. A check name is not a producer: a fork can add a
+      workflow that reports a green run with the expected name, so the match is
+      pinned to one App. Set this to your own App slug if your CI is not GitHub
+      Actions. Empty accepts any producer and is not the default.
+    default: 'github-actions'
+    required: false
+  emit-review:
+    description: >-
+      Submit the formal review when `approval-token` is supplied. 'false' keeps
+      the token out of the review lane entirely. A `true` value without a token
+      is a no-op, not an error.
     default: 'true'
     required: false
 outputs:
   conclusion:
     description: 'Run conclusion: success, failure, or neutral'
     value: ${{ steps.post.outputs.conclusion }}
+  review-event:
+    description: 'GitHub review event submitted: APPROVE, REQUEST_CHANGES, COMMENT, or none'
+    value: ${{ steps.approve.outputs.review-event }}
+  review-state:
+    description: 'State of the submitted review, or why none was submitted'
+    value: ${{ steps.approve.outputs.review-state }}
+  stale-dismissed:
+    description: 'Stale approvals by this identity that were dismissed because they no longer describe the head. "unknown" if the existing reviews could not be read.'
+    value: ${{ steps.approve.outputs.stale-dismissed }}
 runs:
   using: composite
   steps:
-    - uses: actions/setup-node@v4
+    - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
       with:
         node-version: ${{ inputs.node-version }}
-        cache: npm
-        cache-dependency-path: ${{ inputs.cache-dependency-path || format('{0}/package-lock.json', inputs.working-directory || '.') }}
 
-    - name: Install consumer dependencies
+    - name: Prepare pinned Argus runtime
+      id: bootstrap
       shell: bash
-      working-directory: ${{ inputs.working-directory }}
+      env:
+        ARGUS_ACTION_PATH: ${{ github.action_path }}
+        ARGUS_CLI: ${{ inputs.cli }}
+        ARGUS_ARGUS_VERSION: ${{ inputs.argus-version }}
+        ARGUS_CONFIG_PATH: ${{ inputs.config }}
+        ARGUS_WORKING_DIRECTORY: ${{ inputs.working-directory }}
+        ARGUS_REPORT_DIR: ${{ inputs.report-dir }}
+        ARGUS_BROWSER: ${{ inputs.browser }}
+        ARGUS_BUDGET_USD: ${{ inputs.budget-usd }}
+        ARGUS_MAX_COMMENTS: ${{ inputs.max-comments }}
+      run: node "$ARGUS_ACTION_PATH/bootstrap.mjs"
+
+    - name: Reject executable lanes on untrusted pull requests
+      if: inputs.run != 'false' || inputs.install-consumer-dependencies == 'true'
+      shell: bash
+      env:
+        EVENT_NAME: ${{ github.event_name }}
+        HEAD_FORK: ${{ github.event.pull_request.head.repo.fork }}
+      run: |
+        if [ "$EVENT_NAME" = "pull_request_target" ]; then
+          echo "Argus runtime lanes are disabled for pull_request_target." >&2
+          exit 1
+        fi
+        if [ "$EVENT_NAME" = "pull_request" ] && [ "$HEAD_FORK" != "false" ]; then
+          echo "Argus runtime lanes require a same-repository PR or an explicitly trusted workflow." >&2
+          exit 1
+        fi
+        if [ "$EVENT_NAME" != "pull_request" ] && [ "$EVENT_NAME" != "" ]; then
+          echo "Argus runtime lanes are disabled for unlisted CI events: $EVENT_NAME" >&2
+          exit 1
+        fi
+
+    - name: Install consumer dependencies for explicit runtime lanes
+      if: inputs.install-consumer-dependencies == 'true'
+      shell: bash
+      working-directory: ${{ inputs.working-directory || '.' }}
       run: npm ci
 
-    - name: Install Playwright browser
+    - name: Install Playwright browser for explicit runtime lanes
       if: inputs.run != 'false'
       shell: bash
-      working-directory: ${{ inputs.working-directory }}
+      working-directory: ${{ inputs.working-directory || '.' }}
       env:
         ARGUS_BROWSER: ${{ inputs.browser }}
       run: |
-        case "$ARGUS_BROWSER" in
-          chromium|firefox|webkit) ;;
-          *) echo "invalid browser input: '$ARGUS_BROWSER' (expected chromium, firefox, or webkit)"; exit 1 ;;
-        esac
         npx playwright install --with-deps "$ARGUS_BROWSER" || npx playwright install "$ARGUS_BROWSER"
 
-    - name: Stage config
-      shell: bash
-      working-directory: ${{ inputs.working-directory }}
-      run: |
-        if [ "${{ inputs.config }}" != "argus-reviewer.config.ts" ]; then
-          ext="${{ inputs.config }}"
-          ext="${ext##*.}"
-          case "$ext" in
-            ts|json) cp "${{ inputs.config }}" "argus-reviewer.config.$ext" ;;
-            *) echo "unsupported config extension: $ext" >&2; exit 1 ;;
-          esac
-        fi
-
     - name: Build repo index
       if: inputs.index == 'true'
       shell: bash
-      working-directory: ${{ inputs.working-directory }}
+      working-directory: ${{ inputs.working-directory || '.' }}
       env:
-        # Token only feeds trust resolution on issue_comment events —
-        # pull_request* events read fork status from the event payload.
+        ARGUS_ACTION_PATH: ${{ github.action_path }}
         GITHUB_TOKEN: ${{ github.token }}
-      run: ${{ inputs.cli }} index
+        ARGUS_CLI_JSON: ${{ steps.bootstrap.outputs.cli-json }}
+        ARGUS_WORKING_DIRECTORY: ${{ steps.bootstrap.outputs.working-directory }}
+      run: node "$ARGUS_ACTION_PATH/cli.mjs" index
 
-    - name: Run argus-reviewer code review
-      id: code-review
+    - name: Run selected Argus lanes
+      id: verify
       shell: bash
-      working-directory: ${{ inputs.working-directory }}
+      working-directory: ${{ inputs.working-directory || '.' }}
       continue-on-error: true
       env:
+        ARGUS_ACTION_PATH: ${{ github.action_path }}
         OPENROUTER_API_KEY: ${{ inputs.openrouter-api-key }}
         GITHUB_TOKEN: ${{ github.token }}
+        ARGUS_CLI_JSON: ${{ steps.bootstrap.outputs.cli-json }}
+        ARGUS_WORKING_DIRECTORY: ${{ steps.bootstrap.outputs.working-directory }}
+        ARGUS_REPORT_DIR: ${{ inputs.report-dir }}
+        ARGUS_VERIFY_FLOW: ${{ inputs.run != 'false' && '1' || '' }}
         ARGUS_SANDBOX: ${{ inputs.sandbox == 'true' && '1' || '' }}
         ARGUS_MAX_COMMENTS: ${{ inputs.max-comments }}
         ARGUS_DEBUG: '1'
-        ARGUS_REVIEWER_TRACE: >-
-          {"repo":"${{ github.repository }}",
-          "pr":"${{ github.event.pull_request.number }}",
-          "commit":"${{ github.sha }}",
-          "run_id":"${{ github.run_id }}",
-          "run_attempt":"${{ github.run_attempt }}",
-          "workflow":"${{ github.workflow }}"}
-      run: ${{ inputs.cli }} code-review --report-dir "${{ inputs.report-dir }}"
-
-    - name: Run argus-reviewer
-      id: run
-      if: inputs.run != 'false'
-      shell: bash
-      working-directory: ${{ inputs.working-directory }}
-      continue-on-error: true
-      env:
-        OPENROUTER_API_KEY: ${{ inputs.openrouter-api-key }}
-        GITHUB_TOKEN: ${{ github.token }}
-        ARGUS_DEBUG: '1'
         ARGUS_DIFF_BASE: ${{ inputs.diff-base }}
         ARGUS_BUDGET_USD: ${{ inputs.budget-usd }}
         ARGUS_REVIEWER_TRACE: >-
           {"repo":"${{ github.repository }}",
           "pr":"${{ github.event.pull_request.number }}",
-          "commit":"${{ github.sha }}",
+          "commit":"${{ github.event.pull_request.head.sha || github.sha }}",
           "run_id":"${{ github.run_id }}",
           "run_attempt":"${{ github.run_attempt }}",
           "workflow":"${{ github.workflow }}"}
-      run: ${{ inputs.cli }} run --report-dir "${{ inputs.report-dir }}"
+      run: node "$ARGUS_ACTION_PATH/cli.mjs" verify --report-dir "$ARGUS_REPORT_DIR"
 
     - name: Post or update sticky PR comment
       id: post
-      uses: actions/github-script@v7
+      if: always()
+      uses: actions/github-script@f28e40c7f34bde8b3046d885e986cb6290c5673b # v7
       env:
+        ARGUS_ACTION_PATH: ${{ github.action_path }}
         OPENROUTER_API_KEY: ${{ inputs.openrouter-api-key }}
         VISION_E2E_WORKING_DIR: ${{ inputs.working-directory }}
         ARGUS_REPORT_DIR: ${{ inputs.report-dir }}
@@ -160,10 +226,21 @@ runs:
       with:
         github-token: ${{ github.token }}
         script: |
-          const fs = require('fs');
           const path = require('path');
-          const actionPath = process.env.GITHUB_ACTION_PATH;
-          const file = path.join(actionPath, 'sticky-comment.mjs');
-          const code = fs.readFileSync(file, 'utf8');
-          const runFn = new Function('github', 'context', 'core', 'require', `return (async () => {\n${code}\n})()`);
-          return await runFn(github, context, core, require);
+          const actionPath = process.env.ARGUS_ACTION_PATH;
+          const { run } = require(path.join(actionPath, 'sticky-comment.cjs'));
+          return await run({ github, context, core });
+
+    - name: Submit formal approval review
+      id: approve
+      if: always() && inputs.emit-review != 'false'
+      shell: bash
+      env:
+        ARGUS_APPROVAL_TOKEN: ${{ inputs.approval-token }}
+        ARGUS_APPROVAL_EVIDENCE: ${{ inputs.approval-evidence }}
+        ARGUS_APPROVAL_CHECK: ${{ inputs.approval-check }}
+        ARGUS_APPROVAL_CHECK_APP: ${{ inputs.approval-check-app }}
+        ARGUS_REPORT_DIR: ${{ inputs.report-dir }}
+        VISION_E2E_WORKING_DIR: ${{ inputs.working-directory }}
+        ARGUS_HEAD_SHA: ${{ github.event.pull_request.head.sha || github.sha }}
+      run: node "${{ github.action_path }}/emit-review.mjs"