@appliqation/autopilot 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Appliqation Pty Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,302 @@
+# Appliqation Autopilot
+
+**An agentic orchestrator that decides — for real, every time — whether a test case needs
+autonomous testing, a defect fix, new automation, or a pull request, instead of running a
+fixed script.**
+
+Most "AI test automation" tooling is a pipeline with an LLM bolted onto one step. Autopilot
+is different: given one test case, it gathers real signal (current pass/fail state,
+flakiness, linked defects, coverage priority, whether automation already exists), reasons
+about what's actually warranted the way a senior QA engineer scoping their day would, states
+a plan, and executes it — checking real results after every action and adapting when reality
+disagrees with the plan, rather than committing blindly upfront.
+
+It orchestrates five independent, single-purpose agents as ordinary tools it can call. None
+of them know Autopilot exists. Each does one thing well and can be scripted directly if you
+want deterministic control instead. Autopilot is the layer above them that decides *when* and
+*whether* to use each one.
+
+## Introducing the agents
+
+| Agent | Does | Repo |
+|---|---|---|
+| **Autotest** | Runs a test case in a real browser; a second, independent AI judges the result from evidence alone — never its own claim. | [`appliqation-autotest`](https://github.com/appliqation/appliqation-autotest) |
+| **Defect-Fix** | Loads full defect context, locates and applies a real code fix, syncs the scenario, verifies with a real Playwright run. | [`appliqation-defect-fix`](https://github.com/appliqation/appliqation-defect-fix) |
+| **Scriptgen** | Drafts a Playwright script for an untested-but-passing test case, iterating against real runs until genuinely green. | [`appliqation-scriptgen`](https://github.com/appliqation/appliqation-scriptgen) |
+| **PR-Raise** | Fully mechanical, no LLM: commits whatever's already changed, pushes, opens or reuses a pull request. | [`appliqation-pr-raise`](https://github.com/appliqation/appliqation-pr-raise) |
+| **Explorer** | Open-ended exploratory QA — a senior-QA heuristics pass plus security/network/caching/mobile probes, headlessly, the coverage a scripted test case never checks for. | [`appliqation-explorer`](https://github.com/appliqation/appliqation-explorer) |
+
+All five share [`@appliqation/agent-core`](https://github.com/appliqation/appliqation-agent-core), the generic think→act→observe engine, budget tracking, and tool-dispatch machinery underneath each of them.
+
+## Why this is different from "wire an LLM to some CLIs"
+
+- **The reasoning is real, not decorative.** The system prompt (`src/policy/systemPrompt.ts`)
+  encodes an actual decision framework — not "call these tools in order," but genuine
+  branches: a currently-*failing* test case does **not** get a script generated for it (that
+  would encode broken behaviour as a false baseline); a flaky one gets a script but with
+  explicitly lowered confidence in the report; a low-priority one may legitimately get *no*
+  action at all, just a recommendation. Taking no action is a valid outcome, not a failure to
+  route.
+- **It never fabricates an outcome.** Every claim in the final report has to trace back to a
+  real tool result. `run_generate`'s `testRun.ok` and `run_defect_fix`'s `verified` reflect an
+  actually-executed Playwright run, not the model's own claim about it. `run_judge`'s status is
+  polled from Appliqation's own authoritative run record, not parsed out of report prose. If
+  Autopilot says a test passes, it's because it watched that happen.
+- **The reasoning lives here, in the open — not behind a private API.** The five sibling
+  agents are genuinely self-contained; the *judgment* about how to combine them is this
+  repo's own code, fully readable, forkable, and swappable (see
+  [Customizing the policy](#customizing-the-policy)). Nothing about how this agent thinks is
+  hidden behind a server only Appliqation can change. One concrete example:
+  `appliqation-defect-fix` has no way to know, on its own, how much testing a given fix
+  actually needs verified — that call is genuinely Autopilot's to make, from the broader
+  signal (defect history, run context) it's already gathering, and it's required to state
+  that reasoning explicitly rather than pass the sibling agent a generic instruction.
+- **Raising a pull request is opt-in, not assumed.** `run_pr_raise` isn't even in the tool
+  list Autopilot's model sees unless you pass `--allow-pr`. Without it, Autopilot still
+  reasons about whether a PR would be warranted — it just tells you so instead of doing it.
+
+## The complete agentic system
+
+```mermaid
+flowchart TB
+    subgraph Autopilot["appliqation-autopilot"]
+        direction TB
+        Loop["think → act → observe loop"]
+        Policy["policy (system prompt) =<br/>the actual decision framework"]
+        Policy -.drives.-> Loop
+    end
+
+    Ctx["read-only Appliqation context:<br/>get_scenario, get_failure_patterns,<br/>get_defect_context, get_coverage_analysis,<br/>get_automation_readiness, enrich_project_context<br/>(read-only — action=write is refused), ..."]
+
+    Ctx --> Loop
+    Loop -->|run_judge| Autotest[appliqation-autotest]
+    Loop -->|run_defect_fix| DefectFix[appliqation-defect-fix]
+    Loop -->|run_generate| Scriptgen[appliqation-scriptgen]
+    Loop -->|"run_pr_raise<br/>(only if --allow-pr)"| PrRaise[appliqation-pr-raise]
+    Loop -->|"run_explore<br/>(when Phase 2 states a real reason)"| Explorer[appliqation-explorer]
+
+    Autotest -->|real polled verdict| Loop
+    DefectFix -->|"verified: true/false"| Loop
+    Scriptgen -->|"testRun.ok: true/false"| Loop
+    PrRaise -->|PR URL or committed: false| Loop
+    Explorer -->|"findings report + budgetExceeded"| Loop
+```
+
+- **Context tools** are ordinary read-only Appliqation MCP tools — the same signal a human QA lead would look at before deciding where to spend effort. This includes the project's own living context document (`enrich_project_context`, action=read) — known issues, high-risk areas, regression watchlist, pain points, personas — so a TC in a known-risky area gets weighed differently than the same raw evidence somewhere unremarkable. The tool also has a write mode; autopilot can only ever read it — see [Safety](#safety).
+- **Action tools** each spawn the corresponding sibling agent's CLI as a real subprocess with `--json`, and hand the model back the exact, real structured result — never a summary of one.
+- **The policy** (`src/policy/systemPrompt.ts`) is the one piece of genuine "brain" — a detailed, phase-based methodology for gathering context, forming a plan, executing it adaptively, and reporting honestly. It's a plain string. Read it, fork it, replace it.
+
+## Workflow options
+
+Autopilot's judgment is one way to use this family — not the only one. Here are four real shapes, from fully autonomous to fully scripted.
+
+### 1. Full autonomous mode
+
+Point Autopilot at a test case and let it decide everything: gather context, judge current state, fix or generate as warranted, raise the PR.
+
+```mermaid
+sequenceDiagram
+    participant You
+    participant AP as Autopilot
+    participant AT as Autotest
+    participant DF as Defect-Fix
+    participant SG as Scriptgen
+    participant PR as PR-Raise
+
+    You->>AP: run --test-case-uuid X --allow-pr
+    AP->>AP: gather context, form a plan
+    alt no recent evidence
+        AP->>AT: run_judge
+        AT-->>AP: real verdict
+    end
+    alt currently fails, fixable defect exists
+        AP->>DF: run_defect_fix (+ test_instruction)
+        DF-->>AP: verified: true/false
+    else currently passes, no canonical script
+        AP->>SG: run_generate
+        SG-->>AP: testRun.ok: true/false
+    end
+    alt something was verified
+        AP->>PR: run_pr_raise
+        PR-->>AP: PR URL
+    end
+    AP-->>You: full report, every claim tool-backed
+```
+
+```bash
+npx appliqation-autopilot run --test-case-uuid <uuid> --environment Stage --repo-path <path> --allow-pr
+```
+
+### 2. Deterministic CI pipeline (no orchestrator)
+
+Skip Autopilot entirely and script the individual agents directly — full control, zero LLM judgment about *what* to run, still LLM-verified per step.
+
+```mermaid
+flowchart LR
+    A[CI trigger] --> B["appliqation-autotest judge<br/>--test-set-id regression"]
+    B --> C{all passed?}
+    C -- yes --> D[deploy]
+    C -- no --> E[fail the build,<br/>file/notify]
+```
+
+```bash
+npx appliqation-autotest judge --test-set-id <id> --environment Stage --ci
+```
+
+### 3. Defect triage & auto-fix
+
+A regression run surfaces failures and defects get filed. Route each one through Defect-Fix (directly, or via Autopilot for scope judgment), open a PR, let a human review.
+
+```mermaid
+flowchart LR
+    A["CI run finds failures<br/>(defects filed in Appliqation)"] --> B["appliqation-defect-fix fix<br/>--defect-id <id>"]
+    B --> C{verified?}
+    C -- yes --> D["appliqation-pr-raise raise"]
+    C -- no --> E[report what's still broken,<br/>no PR]
+    D --> F[human reviews the PR]
+```
+
+```bash
+npx appliqation-defect-fix fix --defect-id <id> --repo-path <path> --dry-run   # first pass, safe
+npx appliqation-defect-fix fix --defect-id <id> --repo-path <path>            # once trusted
+```
+
+### 4. Coverage backfill
+
+Systematically pay down test-automation debt: find passing-but-unautomated test cases, generate and verify canonical scripts for each, batch them into a PR.
+
+```mermaid
+flowchart LR
+    A["get_automation_readiness:<br/>passing TCs with no canonical script"] --> B["appliqation-scriptgen generate<br/>per test case"]
+    B --> C{testRun.ok?}
+    C -- yes --> D[accumulate written files]
+    C -- no --> E[skip, flag for follow-up]
+    D --> F["appliqation-pr-raise raise<br/>(one PR, batched)"]
+```
+
+```bash
+npx appliqation-scriptgen generate --test-case-uuid <uuid> --repo-path <path> --ci
+```
+
+## Quick start
+
+```bash
+npm install -g @appliqation/autopilot
+```
+
+You'll also need whichever sibling agents autopilot is allowed to call — install the ones
+you want reachable (see [Workflow options](#workflow-options) above for real combinations;
+you don't need all five for every use case):
+
+```bash
+npm install -g @appliqation/autotest @appliqation/defect-fix \
+  @appliqation/scriptgen @appliqation/pr-raise @appliqation/explorer
+```
+
+Each is a plain command name by default (`AUTOTEST_CMD`/`DEFECT_FIX_CMD`/`SCRIPTGEN_CMD`/
+`PR_RAISE_CMD`/`EXPLORER_CMD` in `.env`) — only override these if you're pointing at a local
+development build instead.
+
+Create a `.env` file (in whatever directory you'll run it from) with:
+
+```
+APPQ_API_KEY=your-appliqation-api-key
+ANTHROPIC_API_KEY=your-anthropic-key   # or OPENAI_API_KEY — pick one
+```
+
+```bash
+appliqation-autopilot run \
+  --test-case-uuid <uuid> \
+  --environment Stage \
+  --repo-path /path/to/your/checkout
+```
+
+Watch stderr — every context tool call, every action, and the model's own reasoning
+(`[thinking]` lines) stream live. Add `--allow-pr` once you're ready to let it actually open
+pull requests; add `--json`/`--ci` for a single structured result and a CI-friendly exit code
+instead of the human-readable transcript.
+
+## Customizing the policy
+
+The default policy in `src/policy/systemPrompt.ts` is opinionated: don't automate a currently
+failing test, flag flaky results as lower-confidence, treat "no action needed" as a legitimate
+outcome. Your organization might weigh these differently — more conservative, a different
+priority order, a different report format for your own stakeholders.
+
+You don't need to touch anything else in this repo to change that:
+
+```bash
+npx appliqation-autopilot run --policy ./my-policy.md ...
+# or set POLICY_FILE in .env
+```
+
+Anything you put in that file becomes the system prompt driving every decision. The
+orchestration code (`src/orchestrator/`, `src/tools/`) doesn't change — it just runs whatever
+policy it's given against the same tools.
+
+If what you actually want is full deterministic control with no LLM judgment in the loop at
+all, you don't need Autopilot for that — script `appliqation-autotest`,
+`appliqation-defect-fix`, `appliqation-scriptgen`, and `appliqation-pr-raise` directly; each
+is a complete, independently useful CLI (see [workflow 2](#2-deterministic-ci-pipeline-no-orchestrator)).
+
+## Safety
+
+- `run_pr_raise` is excluded from the tool list entirely unless `--allow-pr` is passed —
+  a hardcoded exclusion, not a soft warning the model could talk itself past.
+- Every meta-tool result is the sibling agent's own real `--json` output — including on
+  failure (a failed/blocked `run_judge`, an unverified `run_generate`/`run_defect_fix`), so a
+  bad outcome is visible to the model as data to reason about, never swallowed.
+- The individual agents carry their own safety invariants independently — a destructive-action
+  gate on any browser interaction, an allowlisted shell surface for `appliqation-scriptgen`'s
+  and `appliqation-defect-fix`'s environment bootstrap, `appliqation-defect-fix`'s own appq
+  writes gated behind its own `--dry-run` (which Autopilot can pass through via
+  `run_defect_fix`'s `dry_run` argument), no credentials ever flowing through an LLM's own
+  context. Autopilot doesn't weaken any of that; it just decides when to invoke it.
+- No credentials of any kind pass through the LLM's context at any point in this repo.
+- `enrich_project_context` is a single Appliqation tool with both `action=read` and
+  `action=write` modes — tool-*name* allowlisting alone can't express "this tool, but
+  only this argument value," so `@appliqation/agent-core`'s `createReadOnlyProjectContextDispatcher`
+  adds an argument-level gate on top: only `action=read` is ever let through, and the
+  check fails closed (a missing or malformed `action` is refused too, not just an
+  explicit `"write"`). Shared with `appliqation-explorer`, which needs the identical
+  guarantee.
+- `appliqation-explorer` is read-only end to end — including on the project context
+  document its own upstream workflow (`appq:runman`) would otherwise write to. When that
+  workflow runs interactively in Claude Code, a human is present at its confirmation gate
+  before anything gets persisted as fact for future passes; a headless `run_explore` call
+  has no equivalent, so it holds the same conservative default as Autopilot itself rather
+  than the permissive one baked into the interactive prompt. See that repo's README for
+  the full reasoning.
+
+## Configuration
+
+See `.env.example` for the full list. In short: `APPQ_API_KEY` + one LLM provider key are
+required; `AUTOTEST_CMD`/`DEFECT_FIX_CMD`/`SCRIPTGEN_CMD`/`PR_RAISE_CMD`/`EXPLORER_CMD` tell
+Autopilot how to reach the sibling agents; `BUDGET_MAX_*` caps the tool-calling loop;
+`POLICY_FILE` points at a custom policy.
+
+Optionally, `AUDIT_MONGO_URI`/`AUDIT_MONGO_DB`/`AUDIT_MONGO_COLLECTION` or
+`AUDIT_JSONL_PATH` records one audit entry per invocation (token usage, duration, real
+outcome) to a datastore this agent family owns — deliberately not part of Appliqation
+itself, since this is a parallel system that uses it, not a feature of it. Every sibling
+agent in the family writes to the same shape; [`appliqation-dashboard`](https://github.com/appliqation/appliqation-dashboard)
+reads it back as an aggregated report. Entirely opt-in — nothing is recorded unless one
+of these is set, and a write failure never affects a real run's outcome.
+
+## Development
+
+```bash
+git clone https://github.com/appliqation/appliqation-autopilot.git
+cd appliqation-autopilot
+npm install
+cp .env.example .env   # fill in APPQ_API_KEY and one LLM provider key
+npm run dev -- run --test-case-uuid <uuid> --environment <name> --repo-path <path>
+npm run typecheck
+npm test
+```
+
+See `CLAUDE.md` for a map of this repo if you're working in it with an AI coding assistant.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/cli/audit.js

@@ -0,0 +1,23 @@
+// Extracted out of cli/index.ts so this is testable without triggering that
+// file's top-level program.parseAsync(process.argv) side effect — same
+// reasoning as appliqation-autotest's cli/resolvers.ts.
+import { safeRecord } from '@appliqation/agent-core';
+export async function recordAutopilotRun(args) {
+    const { sink, startedAt, endedAt, model, usage, testCaseUuid, environment, repoPath, allowPr, result } = args;
+    await safeRecord(sink, {
+        agent: 'appliqation-autopilot',
+        subcommand: 'run',
+        startedAt,
+        endedAt,
+        durationMillis: endedAt - startedAt,
+        model,
+        usage,
+        turns: result?.turns,
+        budgetExceeded: result?.budgetExceeded,
+        exitCode: result ? 0 : 1,
+        outcome: result
+            ? { testCaseUuid, environment, repoPath, allowPr, turns: result.turns, budgetExceeded: result.budgetExceeded, report: result.report }
+            : { testCaseUuid, environment, repoPath, allowPr, error: true },
+    });
+}
+//# sourceMappingURL=audit.js.map

package/dist/cli/audit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.js","sourceRoot":"","sources":["../../src/cli/audit.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,uEAAuE;AACvE,wDAAwD;AAExD,OAAO,EAAE,UAAU,EAAoC,MAAM,yBAAyB,CAAC;AAiBvF,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,IAA4B;IACnE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC9G,MAAM,UAAU,CAAC,IAAI,EAAE;QACrB,KAAK,EAAE,uBAAuB;QAC9B,UAAU,EAAE,KAAK;QACjB,SAAS;QACT,OAAO;QACP,cAAc,EAAE,OAAO,GAAG,SAAS;QACnC,KAAK;QACL,KAAK;QACL,KAAK,EAAE,MAAM,EAAE,KAAK;QACpB,cAAc,EAAE,MAAM,EAAE,cAAc;QACtC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACxB,OAAO,EAAE,MAAM;YACb,CAAC,CAAC,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;YACrI,CAAC,CAAC,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE;KAClE,CAAC,CAAC;AACL,CAAC"}

package/dist/cli/index.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+// `run`: the agentic orchestrator. Reasons over real context to decide
+// whether to run autonomous testing, generate new automation, or raise a
+// PR for it — see src/policy/systemPrompt.ts for the actual methodology
+// (the one real customization point) and src/orchestrator/autopilot.ts for
+// the mechanism.
+import { readFile } from 'node:fs/promises';
+import { Command } from 'commander';
+import { createMcpClient, createAnthropicAdapter, createOpenAiAdapter, createUsageAccumulator } from '@appliqation/agent-core';
+import { config, resolveProvider, resolveModel } from '../config/env.js';
+import { autopilot } from '../orchestrator/autopilot.js';
+import { recordAutopilotRun } from './audit.js';
+function buildAdapter() {
+    const provider = resolveProvider();
+    const model = resolveModel();
+    return provider === 'anthropic'
+        ? createAnthropicAdapter(config.anthropicApiKey, model, config.anthropicMaxTokens)
+        : createOpenAiAdapter(config.openaiApiKey, model, config.openaiMaxOutputTokens);
+}
+function logEvent(prefix) {
+    return (e) => {
+        if (e.type === 'assistant') {
+            const text = (e.detail ?? '').trim();
+            if (text)
+                console.error(`${prefix}[thinking] ${text}`);
+        }
+        else if (e.type === 'tool') {
+            const d = e.detail;
+            console.error(`${prefix}[tool] ${d.name} -> ${d.result.slice(0, 400)}`);
+        }
+        else if (e.type === 'log') {
+            console.error(`${prefix}[log] ${e.detail}`);
+        }
+        else if (e.type === 'usage') {
+            const u = e.detail;
+            const cacheNote = u.cacheReadTokens
+                ? ` (${u.cacheReadTokens} from cache)`
+                : u.cacheWriteTokens
+                    ? ` (${u.cacheWriteTokens} written to cache)`
+                    : '';
+            console.error(`${prefix}[usage] in=${u.inputTokens} out=${u.outputTokens}${cacheNote}`);
+        }
+    };
+}
+const program = new Command();
+program
+    .name('appliqation-autopilot')
+    .description('An agentic orchestrator that reasons over real context (current pass/fail state, flakiness, defects, ' +
+    'coverage priority) to decide whether to run autonomous testing, fix a defect, generate new automation, ' +
+    "or raise a PR for it — a real decision every time, not a fixed script. See README.md for the full story.");
+program
+    .command('run')
+    .description('Route one test case. Gathers context, states a plan, executes it adaptively (run_judge/run_defect_fix/' +
+    'run_generate, and run_pr_raise if --allow-pr), re-checking real results at every step. Never claims an ' +
+    "outcome it did not actually observe via a tool call — see the policy's own non-negotiable rule.")
+    .requiredOption('--test-case-uuid <uuid>', 'test case UUID to route')
+    .requiredOption('--environment <name>', 'environment name — passed to run_judge/run_generate')
+    .requiredOption('--repo-path <path>', 'local repo checkout run_generate/run_pr_raise operate in')
+    .option('--allow-pr', 'authorize run_pr_raise — without this flag, that tool is not even offered to the model')
+    .option('--policy <path>', 'override the bundled decision policy with your own system prompt file')
+    .option('--max-turns <n>', 'override BUDGET_MAX_TURNS for this run')
+    .option('--json', 'print a single structured JSON result instead of the human-readable report')
+    .option('--ci', 'shorthand for --json')
+    .action(async (opts) => {
+    const json = (opts.json ?? false) || (opts.ci ?? false);
+    const client = createMcpClient({ origin: config.appqOrigin, apiKey: config.appqApiKey() });
+    const adapter = buildAdapter();
+    const allowPr = opts.allowPr ?? false;
+    const policyPath = opts.policy ?? config.policyFile;
+    const systemPromptOverride = policyPath ? await readFile(policyPath, 'utf-8') : undefined;
+    const budget = { ...config.budget, ...(opts.maxTurns ? { maxTurns: Number(opts.maxTurns) } : {}) };
+    if (allowPr) {
+        console.error('[setup] run_pr_raise is AUTHORIZED for this invocation.');
+    }
+    else {
+        console.error('[setup] run_pr_raise is not authorized (pass --allow-pr to enable it).');
+    }
+    const startedAt = Date.now();
+    const usage = createUsageAccumulator();
+    const baseLog = logEvent('');
+    let result;
+    try {
+        result = await autopilot({
+            client,
+            adapter,
+            testCaseUuid: opts.testCaseUuid,
+            environment: opts.environment,
+            repoPath: opts.repoPath,
+            budget,
+            metaTools: {
+                autotestCmd: config.autotestCmd,
+                scriptgenCmd: config.scriptgenCmd,
+                prRaiseCmd: config.prRaiseCmd,
+                defectFixCmd: config.defectFixCmd,
+                explorerCmd: config.explorerCmd,
+                commandTimeoutMs: config.commandTimeoutMs,
+                allowPr,
+            },
+            systemPromptOverride,
+            onEvent: (e) => {
+                baseLog(e);
+                if (e.type === 'usage')
+                    usage.onUsage(e.detail);
+            },
+        });
+    }
+    finally {
+        // Audit write happens whether the run succeeded or threw — see
+        // @appliqation/agent-core's audit/sink.ts: safeRecord() (used
+        // inside recordAutopilotRun) never lets a failed/unreachable audit
+        // sink affect this process's real outcome.
+        await recordAutopilotRun({
+            sink: config.auditSink,
+            startedAt,
+            endedAt: Date.now(),
+            model: resolveModel(),
+            usage: usage.totals(),
+            testCaseUuid: opts.testCaseUuid,
+            environment: opts.environment,
+            repoPath: opts.repoPath,
+            allowPr,
+            result,
+        });
+    }
+    if (json) {
+        console.log(JSON.stringify({ report: result.report, turns: result.turns, budgetExceeded: result.budgetExceeded }, null, 2));
+        return;
+    }
+    console.log('\n=== Report ===\n');
+    console.log(result.report);
+    console.error(`\n(${result.turns} turns, budget exceeded: ${result.budgetExceeded})`);
+});
+program.parseAsync(process.argv);
+//# sourceMappingURL=index.js.map

package/dist/cli/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"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"}

package/dist/config/env.js

@@ -0,0 +1,56 @@
+import 'dotenv/config';
+import { DEFAULT_ANTHROPIC_MODEL, DEFAULT_OPENAI_MODEL } from '@appliqation/agent-core/providers';
+import { required, optional } from '@appliqation/agent-core/config';
+import { resolveAuditSink } from '@appliqation/agent-core/audit';
+export const config = {
+    appqOrigin: optional('APPQ_ORIGIN') ?? 'https://appq.appliqation.io',
+    appqApiKey: () => required('APPQ_API_KEY'),
+    anthropicApiKey: optional('ANTHROPIC_API_KEY'),
+    openaiApiKey: optional('OPENAI_API_KEY'),
+    anthropicModel: optional('ANTHROPIC_MODEL'),
+    openaiModel: optional('OPENAI_MODEL'),
+    anthropicMaxTokens: Number(optional('ANTHROPIC_MAX_TOKENS') ?? 8192),
+    openaiMaxOutputTokens: Number(optional('OPENAI_MAX_OUTPUT_TOKENS') ?? 8192),
+    // Generous relative to the other agents in this family — a single
+    // autopilot run legitimately needs several rounds: gather context from
+    // several tools, reason, act, re-evaluate the real result, possibly act
+    // again. Cutting this short would force shallow, single-shot decisions.
+    budget: {
+        maxCalls: Number(optional('BUDGET_MAX_CALLS') ?? 40),
+        maxPages: 999_999, // this agent never drives a browser directly
+        maxMillis: Number(optional('BUDGET_MAX_MILLIS') ?? 30 * 60 * 1000),
+        maxTurns: Number(optional('BUDGET_MAX_TURNS') ?? 30),
+    },
+    // How to invoke the five sibling agents — never a filesystem/private-npm
+    // dependency (this repo is meant to be cloned standalone), just a command
+    // string split on whitespace into [command, ...baseArgs]. Defaults assume
+    // the real packages are installed and on PATH; override to point at a
+    // local dev build (e.g. "node /path/to/appliqation-autotest/dist/cli/index.js").
+    autotestCmd: optional('AUTOTEST_CMD') ?? 'appliqation-autotest',
+    scriptgenCmd: optional('SCRIPTGEN_CMD') ?? 'appliqation-scriptgen',
+    prRaiseCmd: optional('PR_RAISE_CMD') ?? 'appliqation-pr-raise',
+    defectFixCmd: optional('DEFECT_FIX_CMD') ?? 'appliqation-defect-fix',
+    explorerCmd: optional('EXPLORER_CMD') ?? 'appliqation-explorer',
+    commandTimeoutMs: Number(optional('COMMAND_TIMEOUT_MS') ?? 20 * 60 * 1000),
+    // The one real customization point — see src/policy/systemPrompt.ts.
+    policyFile: optional('POLICY_FILE'),
+    // Observability, entirely opt-in — see @appliqation/agent-core's audit/sink.ts.
+    auditSink: resolveAuditSink({
+        auditMongoUri: optional('AUDIT_MONGO_URI'),
+        auditMongoDb: optional('AUDIT_MONGO_DB'),
+        auditMongoCollection: optional('AUDIT_MONGO_COLLECTION'),
+        auditJsonlPath: optional('AUDIT_JSONL_PATH'),
+    }),
+};
+export function resolveProvider() {
+    if (config.anthropicApiKey)
+        return 'anthropic';
+    if (config.openaiApiKey)
+        return 'openai';
+    throw new Error('Set ANTHROPIC_API_KEY or OPENAI_API_KEY');
+}
+export function resolveModel() {
+    const provider = resolveProvider();
+    return provider === 'anthropic' ? (config.anthropicModel ?? DEFAULT_ANTHROPIC_MODEL) : (config.openaiModel ?? DEFAULT_OPENAI_MODEL);
+}
+//# sourceMappingURL=env.js.map

package/dist/config/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","sourceRoot":"","sources":["../../src/config/env.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAC;AACvB,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAClG,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEjE,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,UAAU,EAAE,QAAQ,CAAC,aAAa,CAAC,IAAI,6BAA6B;IACpE,UAAU,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC;IAC1C,eAAe,EAAE,QAAQ,CAAC,mBAAmB,CAAC;IAC9C,YAAY,EAAE,QAAQ,CAAC,gBAAgB,CAAC;IACxC,cAAc,EAAE,QAAQ,CAAC,iBAAiB,CAAC;IAC3C,WAAW,EAAE,QAAQ,CAAC,cAAc,CAAC;IACrC,kBAAkB,EAAE,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAC,IAAI,IAAI,CAAC;IACpE,qBAAqB,EAAE,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,IAAI,IAAI,CAAC;IAC3E,kEAAkE;IAClE,uEAAuE;IACvE,wEAAwE;IACxE,wEAAwE;IACxE,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC;QACpD,QAAQ,EAAE,OAAO,EAAE,6CAA6C;QAChE,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;QAClE,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC;KACrD;IACD,yEAAyE;IACzE,0EAA0E;IAC1E,0EAA0E;IAC1E,sEAAsE;IACtE,iFAAiF;IACjF,WAAW,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,sBAAsB;IAC/D,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,IAAI,uBAAuB;IAClE,UAAU,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,sBAAsB;IAC9D,YAAY,EAAE,QAAQ,CAAC,gBAAgB,CAAC,IAAI,wBAAwB;IACpE,WAAW,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,sBAAsB;IAC/D,gBAAgB,EAAE,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC1E,qEAAqE;IACrE,UAAU,EAAE,QAAQ,CAAC,aAAa,CAAC;IAEnC,gFAAgF;IAChF,SAAS,EAAE,gBAAgB,CAAC;QAC1B,aAAa,EAAE,QAAQ,CAAC,iBAAiB,CAAC;QAC1C,YAAY,EAAE,QAAQ,CAAC,gBAAgB,CAAC;QACxC,oBAAoB,EAAE,QAAQ,CAAC,wBAAwB,CAAC;QACxD,cAAc,EAAE,QAAQ,CAAC,kBAAkB,CAAC;KAC7C,CAAC;CACH,CAAC;AAEF,MAAM,UAAU,eAAe;IAC7B,IAAI,MAAM,CAAC,eAAe;QAAE,OAAO,WAAW,CAAC;IAC/C,IAAI,MAAM,CAAC,YAAY;QAAE,OAAO,QAAQ,CAAC;IACzC,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;AAC7D,CAAC;AAED,MAAM,UAAU,YAAY;IAC1B,MAAM,QAAQ,GAAG,eAAe,EAAE,CAAC;IACnC,OAAO,QAAQ,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,cAAc,IAAI,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,IAAI,oBAAoB,CAAC,CAAC;AACtI,CAAC"}

package/dist/orchestrator/autopilot.js

@@ -0,0 +1,45 @@
+// Ties it together: the read-only appq context tools, the three meta-tools
+// wrapping the sibling agents, and the policy (system prompt) that actually
+// drives judgment — run through @appliqation/agent-core's generic
+// think->act->observe loop directly. No appq prompt fetch at all: the
+// system prompt is local (src/policy/systemPrompt.ts or a --policy
+// override), so runLoop() is used directly rather than runWorkflow()'s
+// appq-fetch indirection, which has nothing to fetch here.
+import { runLoop, fetchAppqToolDefs, createGatedAppqDispatcher, createReadOnlyProjectContextDispatcher, PROJECT_CONTEXT_TOOL } from '@appliqation/agent-core';
+import { READONLY_CONTEXT_TOOLS } from '../tools/safety.js';
+import { metaToolDefs, createMetaToolDispatch } from '../tools/metaTools.js';
+import { buildSystemPrompt } from '../policy/systemPrompt.js';
+export async function autopilot(opts) {
+    const contextToolAllowlist = new Set([...READONLY_CONTEXT_TOOLS, PROJECT_CONTEXT_TOOL]);
+    const appqToolDefs = await fetchAppqToolDefs(opts.client, contextToolAllowlist);
+    // Argument-level gate applied outermost — see @appliqation/agent-core's tools/projectContext.ts —
+    // so a write attempt is refused before anything else decides what to do
+    // with the call, same ordering reasoning as judgeTc.ts's browser-label
+    // correction sitting outside its dry-run interceptor.
+    const gatedAppq = createReadOnlyProjectContextDispatcher(createGatedAppqDispatcher(opts.client, contextToolAllowlist));
+    const metaDispatch = createMetaToolDispatch(opts.metaTools);
+    const metaDefs = metaToolDefs(opts.metaTools);
+    const metaNames = new Set(metaDefs.map((t) => t.name));
+    const dispatch = async (name, args) => {
+        if (metaNames.has(name))
+            return metaDispatch(name, args);
+        return gatedAppq(name, args);
+    };
+    const system = opts.systemPromptOverride ?? buildSystemPrompt(opts.metaTools.allowPr);
+    const seedMessage = [
+        `Test case UUID: ${opts.testCaseUuid}`,
+        `Environment: ${opts.environment}`,
+        `Repo path (for run_generate/run_pr_raise): ${opts.repoPath}`,
+        'Begin now — start with get_scenario.',
+    ].join('\n');
+    return runLoop({
+        adapter: opts.adapter,
+        system,
+        seedMessage,
+        tools: [...appqToolDefs, ...metaDefs],
+        dispatch,
+        budget: opts.budget,
+        onEvent: opts.onEvent,
+    });
+}
+//# sourceMappingURL=autopilot.js.map

package/dist/orchestrator/autopilot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autopilot.js","sourceRoot":"","sources":["../../src/orchestrator/autopilot.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,4EAA4E;AAC5E,kEAAkE;AAClE,sEAAsE;AACtE,mEAAmE;AACnE,uEAAuE;AACvE,2DAA2D;AAE3D,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,sCAAsC,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAE9J,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAe9D,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,IAAsB;IACpD,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,sBAAsB,EAAE,oBAAoB,CAAC,CAAC,CAAC;IACxF,MAAM,YAAY,GAAG,MAAM,iBAAiB,CAAC,IAAI,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAChF,kGAAkG;IAClG,wEAAwE;IACxE,uEAAuE;IACvE,sDAAsD;IACtD,MAAM,SAAS,GAAG,sCAAsC,CAAC,yBAAyB,CAAC,IAAI,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;IACvH,MAAM,YAAY,GAAG,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC5D,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC9C,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAEvD,MAAM,QAAQ,GAAmB,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;QACpD,IAAI,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACzD,OAAO,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC/B,CAAC,CAAC;IAEF,MAAM,MAAM,GAAG,IAAI,CAAC,oBAAoB,IAAI,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACtF,MAAM,WAAW,GAAG;QAClB,mBAAmB,IAAI,CAAC,YAAY,EAAE;QACtC,gBAAgB,IAAI,CAAC,WAAW,EAAE;QAClC,8CAA8C,IAAI,CAAC,QAAQ,EAAE;QAC7D,sCAAsC;KACvC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEb,OAAO,OAAO,CAAC;QACb,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,MAAM;QACN,WAAW;QACX,KAAK,EAAE,CAAC,GAAG,YAAY,EAAE,GAAG,QAAQ,CAAC;QACrC,QAAQ;QACR,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,OAAO,EAAE,IAAI,CAAC,OAAO;KACtB,CAAC,CAAC;AACL,CAAC"}

package/dist/policy/systemPrompt.js

@@ -0,0 +1,159 @@
+// The actual decision-making methodology. This is THE customization point
+// for this agent — see --policy/POLICY_FILE in src/cli/index.ts. Fork this
+// file (or point --policy at your own) to change how autopilot reasons:
+// more conservative, a different priority order, a different report shape.
+// Nothing about the orchestration code around it (src/orchestrator/,
+// src/tools/) needs to change for that — the tool-calling loop is generic;
+// this string is what actually drives its judgment.
+//
+// Deliberately NOT fetched from a server. The individual capabilities this
+// agent orchestrates (autotest, scriptgen, pr-raise) are each self-
+// contained tools that do one thing well; the judgment about how and when
+// to use them belongs here, visible and forkable, not hidden behind a
+// private API only Appliqation can change.
+export function buildSystemPrompt(allowPr) {
+    const prToolNote = allowPr
+        ? '`run_pr_raise` is available for this invocation.'
+        : '`run_pr_raise` is NOT available for this invocation — this is expected and normal, not an error. ' +
+            'Plan around its absence: recommend raising a PR in your final report instead of attempting it.';
+    return `You are an autonomous quality engineering lead deciding where effort is actually warranted for one \
+test case — not a script executing a fixed sequence. Your two responsibilities, in order: (1) figure out, \
+from real evidence, what should happen; (2) make it happen, checking real results at every step rather than \
+assuming your plan survives contact with reality.
+
+${prToolNote}
+
+**Non-negotiable:** every claim in your final report must cite a real tool result. If you did not actually \
+call run_judge, you have no basis to say the test passes or fails. If you did not actually call run_generate \
+and see testRun.ok in its result, you have no basis to say a script is verified. If you did not actually call \
+run_defect_fix and see verified: true in its result, you have no basis to say a defect is fixed. Never \
+paraphrase a hoped-for outcome as an observed one.
+
+## Phase 0 — Prerequisites
+
+Check your own tool list for \`run_pr_raise\`. Its absence just means this invocation wasn't authorized to \
+open pull requests — not something to work around or a reason to stop.
+
+## Phase 1 — Gather context like a senior QA lead would
+
+Call \`get_scenario\` first (scenario intent, sibling test cases, this TC's own steps/expected_results), then \
+pull every signal that would actually change your decision:
+
+- \`get_automation_readiness\` — does a canonical script already exist? If so, run_generate would be \
+redundant; consider whether the existing coverage is enough instead.
+- \`get_failure_patterns\` — this TC's own pass_rate/is_flaky, and its siblings'. A flaky TC changes your \
+confidence in any result you get, not just a fact to mention.
+- \`get_defect_context\` for any defect linked to this TC or surfaced above — a known, unresolved root cause \
+changes what a failure *means* (a known bug, not new information) and whether generating a script now would \
+just encode broken behaviour as a passing baseline. This is also the trigger signal for \`run_defect_fix\`: \
+its \`defect_history\`, \`run_context\`, and \`routes_visited\` are exactly what you need to judge both whether \
+the root cause looks fixable and — per Phase 2 below — how much verification the fix will actually need.
+- \`get_coverage_analysis\` / \`get_quality_context\` — is this TC/feature area actually a priority right \
+now, or is effort better spent elsewhere? A routing decision includes deciding effort isn't warranted.
+- \`get_evidence_summary\` / \`get_run_evidence\` / \`get_execution_evidence\` / \`get_test_results\` — has \
+this TC been exercised recently, by a human or agentically, and what did that show?
+- \`enrich_project_context\` (action=read) — the project's own living context document: \
+\`known_issues\`, \`high_risk_areas\`, \`regression_watchlist\`, \`pain_points\`, \`critical_features\`, \
+\`personas\`. This is business/risk context no other tool here carries. Weigh it into Phase 2, don't just \
+fetch it and move on: a TC sitting in a \`high_risk_area\` or matching a \`known_issue\` is a stronger signal \
+for action than the same raw evidence would be in an unremarkable area. This tool also has a write mode — \
+you don't have access to it; only action=read is available to you, enforced below the prompt level, so there's \
+nothing to avoid here beyond calling it the normal way.
+
+Don't stop at the first signal that seems to answer the question — weigh several of these against each \
+other, the way a real engineer would before committing effort.
+
+## Phase 2 — Form and state a plan
+
+Before acting, write out your assessment and the plan it leads to — this is not a formality, it's the actual \
+reasoning a reviewer should be able to audit later. Cover:
+
+- **Current state**: is this TC known to currently pass, currently fail, or unknown (no recent evidence of \
+any kind)?
+- **Decision**, and why —
+  - No recent evidence exists at all → run_judge first. Never generate a script for a TC whose current \
+behaviour you haven't actually confirmed.
+  - Evidence shows the TC currently **fails** → do not generate a script now — that would lock in broken \
+behaviour as a false baseline. If \`get_defect_context\` surfaced an open defect for this TC with a \
+root cause that looks fixable from the evidence you already have (routes_visited, console/network errors, \
+defect_history), \`run_defect_fix\` is warranted. If no such defect exists, or the root cause isn't clear \
+from available evidence, recommend the failure be investigated/fixed first instead of guessing.
+  - **Calling \`run_defect_fix\`**: you MUST compose its \`test_instruction\` yourself from what Phase 1 \
+already told you — never pass a vague or generic instruction. \`defect_history\` showing this component has \
+failed before (even if since resolved) signals fragility → instruct a broader, scenario-level re-test, not \
+just the one reproducing TC. An isolated, first-time defect with no such history → the single reproducing TC \
+is genuinely sufficient, say so explicitly. This is the actual point of routing through you instead of \
+appliqation-defect-fix directly: it has no way to know how much verification is warranted on its own — that \
+judgment is yours to make and state.
+  - Evidence shows the TC currently **passes** and no canonical script exists → a strong candidate for \
+run_generate, to lock in regression coverage while behaviour is known-good.
+  - \`is_flaky\` is true → still worth generating, but say so explicitly and lower your stated confidence — \
+flag it as needing a stabilisation pass, don't present it as equivalent to a stable TC's result.
+  - Coverage/quality signals suggest this isn't actually a priority right now → it's entirely valid to \
+conclude no autonomous action is warranted and only report a recommendation. Taking no action is a \
+legitimate decision, not a failure to route.
+  - A verified script exists, or run_defect_fix returned verified: true (from this run or already) and \
+run_pr_raise is available → raising the PR is the natural next step; if it's not available, say so and \
+recommend it as a manual follow-up.
+  - **\`run_explore\`** is a genuinely separate axis from everything above, weighed alongside whichever \
+branch you land on, not instead of it. The question isn't "does this TC match one of a few known patterns" — \
+it's "does what I've *actually* gathered about this specific TC give me a real, statable reason to suspect \
+the literal expected_result won't be enough." Illustrative, not exhaustive: a defect fix on a page \
+high_risk_areas/defect_history already flags as fragile, or on a TC marked is_flaky, is a reasonable moment \
+to ask whether the surrounding page deserves a broader look before run_pr_raise — but only if that fragility \
+signal is actually present for *this* TC, not by default on every fix. enrich_project_context's known_issues \
+showing a recurring category (e.g. several past localStorage issues) that this TC's feature also touches is \
+another. A new UI/visual component is another — run_judge and run_explore answer different questions and \
+either can be warranted, together or alone. The bar is a specific reason drawn from this TC's own gathered \
+context, stated here like every other routing decision — not routine practice, and not "more testing is \
+always better." Calling it reflexively burns budget without adding signal, which defeats the actual goal \
+(better testing, not more testing); not calling it when the context clearly warrants it misses exactly the \
+kind of gap this exists to catch. Absence of a stated reason means don't call it, the same as every other \
+tool in this policy. Compose \`prompt\` yourself from that stated reason — a generic "explore this page" \
+instruction wastes the specificity you just reasoned your way to, the same discipline run_defect_fix's \
+test_instruction already requires of you.
+- **Planned sequence**: the specific tool calls you intend to make, in order — understanding you will \
+re-evaluate after each real result in Phase 3, not execute this blindly.
+
+## Phase 3 — Execute adaptively
+
+Carry out the plan, but treat every step's result as new information, not a checkbox:
+
+- After run_judge: if its real, polled status is failed/blocked, stop and do not proceed to run_generate — \
+return to Phase 2's reasoning with this new evidence (usually: report the failure, don't automate it, or \
+route to run_defect_fix if a fixable root cause exists).
+- After run_defect_fix: only treat it as a success if its result says \`verified: true\` — the same \
+non-negotiable discipline as run_generate's \`testRun.ok\`, derived from a real, independently-executed \
+Playwright run against the testing scope you yourself specified, never the model's own claim from inside \
+that run. Only proceed to run_pr_raise once you see \`verified: true\`; \`verified: false\` means stop and \
+report what's still broken, not attempt a second guess at a fix in the same pass.
+- After run_generate: only treat it as a success if its result says \`testRun.ok: true\` — that field is \
+derived from actually executing the generated script, never from the model's own claim inside that run. \
+\`testRun.ran: true, testRun.ok: false\` means it ran and failed for real — do not proceed to run_pr_raise \
+with an unverified or failing script.
+- After run_pr_raise (if called): confirm it actually returned a PR URL before reporting one — \
+\`committed: false\` means there was nothing to raise a PR for at all.
+- After run_explore (if called): its result is a report to read and weigh, not a pass/fail verdict — \
+\`budgetExceeded: true\` means the pass ended early and the report may be incomplete, say so if it happened. \
+A finding it surfaces can change your Phase 2 plan (e.g. it turns up a real issue that changes whether a fix \
+or a PR is still warranted as originally planned) — treat it as new evidence like any other real result, not \
+a side quest that doesn't feed back into the rest of your reasoning.
+- If reality diverges from your Phase 2 plan at any point, adapt and say so — a plan that survives \
+unchanged despite contradicting evidence is a red flag, not diligence.
+
+## Phase 4 — Final report
+
+Structure it plainly:
+
+- **Plan & reasoning** — what you decided and why, from Phase 2.
+- **Evidence gathered** — the signals from Phase 1 that actually drove the decision (cite specifics: pass \
+rates, defect IDs, coverage gaps — not vague summaries).
+- **Actions taken** — each tool you actually called and its real result (verdict/status from run_judge, \
+verified and the testing scope you specified from run_defect_fix, testRun.ok and the written file path from \
+run_generate, PR URL from run_pr_raise, findings and budgetExceeded from run_explore — plus the reason you \
+called it, from Phase 2). If you took no action, say that plainly and why.
+- **Authorization notes** — if run_pr_raise wasn't available and a PR would otherwise have been warranted, \
+say so explicitly as a recommendation, not a silent gap.
+- **Recommendation** — what, if anything, a human should do next.`;
+}
+//# sourceMappingURL=systemPrompt.js.map

package/dist/policy/systemPrompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"systemPrompt.js","sourceRoot":"","sources":["../../src/policy/systemPrompt.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,2EAA2E;AAC3E,wEAAwE;AACxE,2EAA2E;AAC3E,qEAAqE;AACrE,2EAA2E;AAC3E,oDAAoD;AACpD,EAAE;AACF,2EAA2E;AAC3E,oEAAoE;AACpE,0EAA0E;AAC1E,sEAAsE;AACtE,2CAA2C;AAE3C,MAAM,UAAU,iBAAiB,CAAC,OAAgB;IAChD,MAAM,UAAU,GAAG,OAAO;QACxB,CAAC,CAAC,kDAAkD;QACpD,CAAC,CAAC,mGAAmG;YACnG,gGAAgG,CAAC;IAErG,OAAO;;;;;EAKP,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAqIsD,CAAC;AACnE,CAAC"}

package/dist/tools/metaTools.js

@@ -0,0 +1,220 @@
+// Wraps the five sibling agents (appliqation-autotest, appliqation-scriptgen,
+// appliqation-defect-fix, appliqation-pr-raise, appliqation-explorer) as ordinary
+// LLM-callable tools. Never a filesystem or
+// private-npm dependency — each is invoked as a configured command string
+// (see src/config/env.ts), spawned via child_process.execFile with an
+// explicit argv array (never a shell string), consuming the CLI's own
+// --json output. The model sees the REAL structured result every time —
+// verified/testRun.ok/a real PR URL — never a paraphrase of one.
+import { execFile } from 'node:child_process';
+// Same hand-rolled wrapper used by appliqation-scriptgen/appliqation-pr-raise,
+// for the same reason: util.promisify(execFile) only resolves {stdout,
+// stderr} via an internal Node symbol a mocked module in tests won't carry.
+function execFileAsync(command, args, options) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        execFile(command, args, options, (error, stdout, stderr) => {
+            if (error) {
+                const failure = error;
+                failure.stdout = String(stdout ?? '');
+                failure.stderr = String(stderr ?? '');
+                rejectPromise(failure);
+            }
+            else {
+                resolvePromise({ stdout: String(stdout ?? ''), stderr: String(stderr ?? '') });
+            }
+        });
+    });
+}
+/** Splits a configured command string ("node /path/to/cli.js") into [command, ...baseArgs]. */
+export function parseCommand(cmd) {
+    const parts = cmd.trim().split(/\s+/).filter(Boolean);
+    if (parts.length === 0)
+        throw new Error(`Empty command string: "${cmd}"`);
+    return [parts[0], parts.slice(1)];
+}
+export function metaToolDefs(cfg) {
+    const defs = [
+        {
+            name: 'run_judge',
+            description: 'Run autonomous testing (a real executor + validator pass) for one test case against a live ' +
+                "environment. Returns the real, appq-polled outcome. This is the ONLY way to know a test case's " +
+                'current pass/fail state — never assume it from prior context alone.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    test_case_uuid: { type: 'string' },
+                    environment: { type: 'string' },
+                    dry_run: {
+                        type: 'boolean',
+                        description: 'Suppress writeback to Appliqation — use when you only need to observe current behaviour, not record a verdict.',
+                    },
+                },
+                required: ['test_case_uuid', 'environment'],
+            },
+        },
+        {
+            name: 'run_generate',
+            description: 'Draft and REALLY verify a Playwright script for one test case — it actually runs the generated ' +
+                "script; the result's testRun.ok reflects a real, independently-checked outcome, never the model's " +
+                'own claim from inside that run. Only call this once you know (via run_judge or existing evidence) ' +
+                'that the test case currently passes — generating a script for a currently-failing test case would ' +
+                'encode broken behaviour as a false baseline.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    test_case_uuid: { type: 'string' },
+                    environment: { type: 'string', description: 'Optional — offered to the generator as base-URL context.' },
+                    repo_path: { type: 'string' },
+                },
+                required: ['test_case_uuid', 'repo_path'],
+            },
+        },
+        {
+            name: 'run_defect_fix',
+            description: 'Fix a defect: loads full defect context, locates and applies a real code fix, syncs the Appliqation ' +
+                'scenario, and verifies the fix by actually running Playwright — the result\'s verified field reflects ' +
+                'a real, independently-checked outcome, never the model\'s own claim from inside that run. ' +
+                'test_instruction is REQUIRED — you must state, from your own gathered evidence (defect_history, ' +
+                'run_context, is_flaky), what testing scope this fix actually needs verified beyond just the single ' +
+                'reproducing test case (e.g. "also re-run the whole scenario — this component has a history of ' +
+                'regressions" or "the single reproducing test case is sufficient — this is an isolated, one-off defect"). ' +
+                'Never call this with a vague or empty instruction.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    defect_id: { type: 'string' },
+                    repo_path: { type: 'string' },
+                    test_instruction: {
+                        type: 'string',
+                        description: 'Required — your own assessment of the testing scope this fix needs, from Phase 1 evidence.',
+                    },
+                    dry_run: {
+                        type: 'boolean',
+                        description: 'Suppress the Appliqation scenario/run writeback — use when you only need to observe whether a fix is achievable, not commit one.',
+                    },
+                },
+                required: ['defect_id', 'repo_path', 'test_instruction'],
+            },
+        },
+        {
+            name: 'run_explore',
+            description: 'Run a headless exploratory-QA pass (appq:runman) against a live target — open-ended senior-QA ' +
+                'heuristics, accessibility, security/network/caching probes, the kind of coverage a scripted test case ' +
+                'never checks for. Not a routine step: call it only when your own gathered context gives you a real, ' +
+                'statable reason to suspect the literal test case in front of you is not enough on its own (see the ' +
+                'policy\'s Phase 2 for how to judge that). prompt should state the exploration intent in plain English ' +
+                '— what you actually want covered, not a generic instruction.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    prompt: { type: 'string', description: 'Plain-English exploration intent — what to cover and why, from your own gathered context.' },
+                    project_id: { type: 'integer' },
+                    site_url: { type: 'string' },
+                },
+                required: ['prompt'],
+            },
+        },
+    ];
+    // Hardcoded exclusion, not a soft warning — matches every other
+    // non-negotiable safety boundary in this agent family. If --allow-pr
+    // wasn't passed to this CLI invocation, this tool simply isn't in the
+    // list the model ever sees; there's no way for it to attempt this.
+    if (cfg.allowPr) {
+        defs.push({
+            name: 'run_pr_raise',
+            description: "Commit whatever run_generate already wrote in repo_path, push, and open (or reuse) a pull " +
+                'request. Only call this after run_generate reported testRun.ok: true for the same repo_path — ' +
+                'never raise a PR for a script you have not seen independently verified.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    project_id: { type: 'integer' },
+                    repo_path: { type: 'string' },
+                    branch_name: { type: 'string' },
+                    pr_title: { type: 'string' },
+                    pr_body: { type: 'string' },
+                },
+                required: ['project_id', 'repo_path', 'branch_name', 'pr_title'],
+            },
+        });
+    }
+    return defs;
+}
+async function runCliJson(baseCmd, subcommand, args, timeoutMs) {
+    const [command, baseArgs] = parseCommand(baseCmd);
+    const fullArgs = [...baseArgs, subcommand, ...args, '--json'];
+    try {
+        const { stdout } = await execFileAsync(command, fullArgs, { timeout: timeoutMs, maxBuffer: 20 * 1024 * 1024 });
+        return { ok: true, text: stdout.trim() || '{}' };
+    }
+    catch (err) {
+        const e = err;
+        // Every sibling CLI prints its --json summary to stdout BEFORE setting
+        // a non-zero exit code on a real failure (judge failed/blocked,
+        // generate unverified) — recover it; it's real signal, not noise.
+        const out = (e.stdout ?? '').trim();
+        if (out)
+            return { ok: false, text: out };
+        return { ok: false, text: `${baseCmd} ${subcommand} failed: ${e.stderr || e.message}` };
+    }
+}
+export function createMetaToolDispatch(cfg) {
+    return async (name, args) => {
+        switch (name) {
+            case 'run_judge': {
+                const cliArgs = ['--test-case-uuid', String(args.test_case_uuid), '--environment', String(args.environment)];
+                if (args.dry_run)
+                    cliArgs.push('--dry-run');
+                return runCliJson(cfg.autotestCmd, 'judge', cliArgs, cfg.commandTimeoutMs);
+            }
+            case 'run_generate': {
+                const cliArgs = ['--test-case-uuid', String(args.test_case_uuid), '--repo-path', String(args.repo_path)];
+                if (args.environment)
+                    cliArgs.push('--environment', String(args.environment));
+                return runCliJson(cfg.scriptgenCmd, 'generate', cliArgs, cfg.commandTimeoutMs);
+            }
+            case 'run_defect_fix': {
+                const cliArgs = [
+                    '--defect-id',
+                    String(args.defect_id),
+                    '--repo-path',
+                    String(args.repo_path),
+                    '--test-instruction',
+                    String(args.test_instruction),
+                ];
+                if (args.dry_run)
+                    cliArgs.push('--dry-run');
+                return runCliJson(cfg.defectFixCmd, 'fix', cliArgs, cfg.commandTimeoutMs);
+            }
+            case 'run_explore': {
+                const cliArgs = ['--prompt', String(args.prompt)];
+                if (args.project_id !== undefined)
+                    cliArgs.push('--project-id', String(args.project_id));
+                if (args.site_url)
+                    cliArgs.push('--site-url', String(args.site_url));
+                return runCliJson(cfg.explorerCmd, 'explore', cliArgs, cfg.commandTimeoutMs);
+            }
+            case 'run_pr_raise': {
+                if (!cfg.allowPr) {
+                    return { ok: false, text: 'run_pr_raise is not authorized for this invocation (--allow-pr was not set on appliqation-autopilot).' };
+                }
+                const cliArgs = [
+                    '--project-id',
+                    String(args.project_id),
+                    '--repo-path',
+                    String(args.repo_path),
+                    '--branch-name',
+                    String(args.branch_name),
+                    '--pr-title',
+                    String(args.pr_title),
+                ];
+                if (args.pr_body)
+                    cliArgs.push('--pr-body', String(args.pr_body));
+                return runCliJson(cfg.prRaiseCmd, 'raise', cliArgs, cfg.commandTimeoutMs);
+            }
+            default:
+                return { ok: false, text: `Unknown meta tool "${name}"` };
+        }
+    };
+}
+//# sourceMappingURL=metaTools.js.map

package/dist/tools/metaTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metaTools.js","sourceRoot":"","sources":["../../src/tools/metaTools.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,kFAAkF;AAClF,4CAA4C;AAC5C,0EAA0E;AAC1E,sEAAsE;AACtE,sEAAsE;AACtE,wEAAwE;AACxE,iEAAiE;AAEjE,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAc9C,+EAA+E;AAC/E,uEAAuE;AACvE,4EAA4E;AAC5E,SAAS,aAAa,CACpB,OAAe,EACf,IAAc,EACd,OAA+C;IAE/C,OAAO,IAAI,OAAO,CAAC,CAAC,cAAc,EAAE,aAAa,EAAE,EAAE;QACnD,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;YACzD,IAAI,KAAK,EAAE,CAAC;gBACV,MAAM,OAAO,GAAG,KAAoB,CAAC;gBACrC,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;gBACtC,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;gBACtC,aAAa,CAAC,OAAO,CAAC,CAAC;YACzB,CAAC;iBAAM,CAAC;gBACN,cAAc,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;YACjF,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED,+FAA+F;AAC/F,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACtD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,GAAG,GAAG,CAAC,CAAC;IAC1E,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACpC,CAAC;AAaD,MAAM,UAAU,YAAY,CAAC,GAAoB;IAC/C,MAAM,IAAI,GAAiB;QACzB;YACE,IAAI,EAAE,WAAW;YACjB,WAAW,EACT,6FAA6F;gBAC7F,iGAAiG;gBACjG,qEAAqE;YACvE,WAAW,EAAE;gBACX,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,cAAc,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBAClC,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBAC/B,OAAO,EAAE;wBACP,IAAI,EAAE,SAAS;wBACf,WAAW,EAAE,gHAAgH;qBAC9H;iBACF;gBACD,QAAQ,EAAE,CAAC,gBAAgB,EAAE,aAAa,CAAC;aAC5C;SACF;QACD;YACE,IAAI,EAAE,cAAc;YACpB,WAAW,EACT,iGAAiG;gBACjG,oGAAoG;gBACpG,oGAAoG;gBACpG,oGAAoG;gBACpG,8CAA8C;YAChD,WAAW,EAAE;gBACX,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,cAAc,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBAClC,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,0DAA0D,EAAE;oBACxG,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;iBAC9B;gBACD,QAAQ,EAAE,CAAC,gBAAgB,EAAE,WAAW,CAAC;aAC1C;SACF;QACD;YACE,IAAI,EAAE,gBAAgB;YACtB,WAAW,EACT,sGAAsG;gBACtG,wGAAwG;gBACxG,4FAA4F;gBAC5F,kGAAkG;gBAClG,qGAAqG;gBACrG,gGAAgG;gBAChG,2GAA2G;gBAC3G,oDAAoD;YACtD,WAAW,EAAE;gBACX,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBAC7B,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBAC7B,gBAAgB,EAAE;wBAChB,IAAI,EAAE,QAAQ;wBACd,WAAW,EAAE,4FAA4F;qBAC1G;oBACD,OAAO,EAAE;wBACP,IAAI,EAAE,SAAS;wBACf,WAAW,EAAE,kIAAkI;qBAChJ;iBACF;gBACD,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,kBAAkB,CAAC;aACzD;SACF;QACD;YACE,IAAI,EAAE,aAAa;YACnB,WAAW,EACT,gGAAgG;gBAChG,wGAAwG;gBACxG,sGAAsG;gBACtG,qGAAqG;gBACrG,wGAAwG;gBACxG,8DAA8D;YAChE,WAAW,EAAE;gBACX,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,2FAA2F,EAAE;oBACpI,UAAU,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;oBAC/B,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;iBAC7B;gBACD,QAAQ,EAAE,CAAC,QAAQ,CAAC;aACrB;SACF;KACF,CAAC;IAEF,gEAAgE;IAChE,qEAAqE;IACrE,sEAAsE;IACtE,mEAAmE;IACnE,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;QAChB,IAAI,CAAC,IAAI,CAAC;YACR,IAAI,EAAE,cAAc;YACpB,WAAW,EACT,4FAA4F;gBAC5F,gGAAgG;gBAChG,yEAAyE;YAC3E,WAAW,EAAE;gBACX,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,UAAU,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;oBAC/B,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBAC7B,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBAC/B,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBAC5B,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;iBAC5B;gBACD,QAAQ,EAAE,CAAC,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,UAAU,CAAC;aACjE;SACF,CAAC,CAAC;IACL,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,KAAK,UAAU,UAAU,CAAC,OAAe,EAAE,UAAkB,EAAE,IAAc,EAAE,SAAiB;IAC9F,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;IAClD,MAAM,QAAQ,GAAG,CAAC,GAAG,QAAQ,EAAE,UAAU,EAAE,GAAG,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC9D,IAAI,CAAC;QACH,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,aAAa,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI,EAAE,CAAC,CAAC;QAC/G,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;IACnD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,GAAG,GAAkB,CAAC;QAC7B,uEAAuE;QACvE,gEAAgE;QAChE,kEAAkE;QAClE,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QACpC,IAAI,GAAG;YAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;QACzC,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,IAAI,UAAU,YAAY,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC;IAC1F,CAAC;AACH,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,GAAoB;IACzD,OAAO,KAAK,EAAE,IAAY,EAAE,IAA6B,EAAuB,EAAE;QAChF,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,WAAW,CAAC,CAAC,CAAC;gBACjB,MAAM,OAAO,GAAG,CAAC,kBAAkB,EAAE,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,eAAe,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;gBAC7G,IAAI,IAAI,CAAC,OAAO;oBAAE,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;gBAC5C,OAAO,UAAU,CAAC,GAAG,CAAC,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC;YAC7E,CAAC;YACD,KAAK,cAAc,CAAC,CAAC,CAAC;gBACpB,MAAM,OAAO,GAAG,CAAC,kBAAkB,EAAE,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;gBACzG,IAAI,IAAI,CAAC,WAAW;oBAAE,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;gBAC9E,OAAO,UAAU,CAAC,GAAG,CAAC,YAAY,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC;YACjF,CAAC;YACD,KAAK,gBAAgB,CAAC,CAAC,CAAC;gBACtB,MAAM,OAAO,GAAG;oBACd,aAAa;oBACb,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;oBACtB,aAAa;oBACb,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;oBACtB,oBAAoB;oBACpB,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC;iBAC9B,CAAC;gBACF,IAAI,IAAI,CAAC,OAAO;oBAAE,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;gBAC5C,OAAO,UAAU,CAAC,GAAG,CAAC,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC;YAC5E,CAAC;YACD,KAAK,aAAa,CAAC,CAAC,CAAC;gBACnB,MAAM,OAAO,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;gBAClD,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS;oBAAE,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;gBACzF,IAAI,IAAI,CAAC,QAAQ;oBAAE,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;gBACrE,OAAO,UAAU,CAAC,GAAG,CAAC,WAAW,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC;YAC/E,CAAC;YACD,KAAK,cAAc,CAAC,CAAC,CAAC;gBACpB,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;oBACjB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,uGAAuG,EAAE,CAAC;gBACtI,CAAC;gBACD,MAAM,OAAO,GAAG;oBACd,cAAc;oBACd,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC;oBACvB,aAAa;oBACb,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;oBACtB,eAAe;oBACf,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC;oBACxB,YAAY;oBACZ,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC;iBACtB,CAAC;gBACF,IAAI,IAAI,CAAC,OAAO;oBAAE,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;gBAClE,OAAO,UAAU,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC;YAC5E,CAAC;YACD;gBACE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,sBAAsB,IAAI,GAAG,EAAE,CAAC;QAC9D,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}

package/dist/tools/safety.js

@@ -0,0 +1,33 @@
+// This agent's own domain knowledge of which appq tools it may touch — the
+// enforcement mechanism (assertToolAllowed / the gated dispatcher) lives in
+// @appliqation/agent-core, shared with every sibling agent; only the
+// allowlist content is local. Broader than a single-purpose workflow's
+// palette on purpose — a genuine routing decision needs the same breadth of
+// signal a senior engineer would look at, not one field. Zero write tools —
+// this agent itself never calls an appq write tool; write-adjacent action
+// happens only through the meta-tools (src/tools/metaTools.ts), which are
+// themselves backed by the sibling agents' own safety boundaries.
+export const READONLY_CONTEXT_TOOLS = new Set([
+    'get_scenario',
+    'get_automation_readiness',
+    'get_failure_patterns',
+    'get_defect_context',
+    'get_coverage_analysis',
+    'get_quality_context',
+    'get_evidence_summary',
+    'get_run_evidence',
+    'get_execution_evidence',
+    'get_test_results',
+    'search_tests',
+    'get_project_settings',
+]);
+// enrich_project_context is a SINGLE MCP tool with both action=read and
+// action=write modes — not two separate tools. Kept out of
+// READONLY_CONTEXT_TOOLS on purpose: that set's whole guarantee is "no
+// write capability under any argument," and folding this in would quietly
+// weaken that guarantee for every tool in it, not just this one.
+// PROJECT_CONTEXT_TOOL itself, and the argument-level gate that enforces
+// read-only access to it, now live in @appliqation/agent-core's
+// tools/projectContext.ts — shared with every other headless agent that
+// needs the identical guarantee, not just this one.
+//# sourceMappingURL=safety.js.map

package/dist/tools/safety.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safety.js","sourceRoot":"","sources":["../../src/tools/safety.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,4EAA4E;AAC5E,qEAAqE;AACrE,uEAAuE;AACvE,4EAA4E;AAC5E,4EAA4E;AAC5E,0EAA0E;AAC1E,0EAA0E;AAC1E,kEAAkE;AAElE,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,GAAG,CAAC;IAC5C,cAAc;IACd,0BAA0B;IAC1B,sBAAsB;IACtB,oBAAoB;IACpB,uBAAuB;IACvB,qBAAqB;IACrB,sBAAsB;IACtB,kBAAkB;IAClB,wBAAwB;IACxB,kBAAkB;IAClB,cAAc;IACd,sBAAsB;CACvB,CAAC,CAAC;AAEH,wEAAwE;AACxE,2DAA2D;AAC3D,uEAAuE;AACvE,0EAA0E;AAC1E,iEAAiE;AACjE,yEAAyE;AACzE,gEAAgE;AAChE,wEAAwE;AACxE,oDAAoD"}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@appliqation/autopilot",
+  "version": "0.1.1",
+  "description": "An agentic orchestrator that decides, per test case, whether to run autonomous testing, generate new automation, or raise a pull request for it \u2014 reasoning over real signal (current pass/fail state, flakiness, linked defects, coverage priority), not a fixed script. Reasoning lives entirely in this repo, not a private server.",
+  "type": "module",
+  "bin": {
+    "appliqation-autopilot": "./dist/cli/index.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsx src/cli/index.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint src --ext .ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@appliqation/agent-core": "^0.1.0",
+    "commander": "^13.1.0",
+    "dotenv": "^16.4.7"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2",
+    "vitest": "^3.2.7"
+  }
+}