@aarwitz/tapp 0.15.0 → 0.16.0

package/docs/scenarios.md

@@ -1,6 +1,6 @@
 # Multi-actor Scenarios
 
-A Scenario is Tapp's low-level deterministic multi-actor execution format in `.autotap/scenarios/*.yml`. It uses the same semantic actions, polling assertions, timeouts, evidence markers, and merge policy as a Flow, but adds isolated named actors, shared variables, and explicit lifecycle steps. The customer-facing business authoring layer is a TypeScript [release contract](release-contracts.md), which composes reusable Tasks and compiles to this runtime instead of duplicating UI steps.
+A Scenario is Tapp's low-level deterministic multi-actor execution format in `.tapp/scenarios/*.yml`. It uses the same semantic actions, polling assertions, timeouts, evidence markers, and merge policy as a Flow, but adds isolated named actors, shared variables, and explicit lifecycle steps. The customer-facing business authoring layer is a TypeScript [release contract](release-contracts.md), which composes reusable Tasks and compiles to this runtime instead of duplicating UI steps.
 
 Ordinary replay is keyless. AI may propose a Scenario during authoring, but no model, API key, or coding agent participates when CI executes it.
 
@@ -61,13 +61,13 @@ teardown:
 ## Run it
 
 ```bash
-tapp scenario validate .autotap/scenarios/social-system.yml
+tapp scenario validate .tapp/scenarios/social-system.yml
 ALICE_EMAIL=alice@example.test ALICE_PASSWORD=demo \
 BOB_EMAIL=bob@example.test BOB_PASSWORD=demo \
-  tapp scenario run .autotap/scenarios/social-system.yml
+  tapp scenario run .tapp/scenarios/social-system.yml
 
 tapp ci --platform web --url http://127.0.0.1:4180 \
-  --scenarios '.autotap/scenarios/*.yml' \
+  --scenarios '.tapp/scenarios/*.yml' \
   --json-out tapp-report.json --md-out tapp-report.md
 ```
 
@@ -78,16 +78,16 @@ GitHub Action:
   with:
     platform: web
     url: http://127.0.0.1:4180
-    scenarios: .autotap/scenarios/*.yml
+    scenarios: .tapp/scenarios/*.yml
 ```
 
 MCP clients call `tapp_scenario_run` with `scenarioPath`, or an inline reviewed Scenario. The structured result identifies `kind: scenario`, actual executed/total steps, and actor-tagged steps.
 
 ## Verified fixture and boundaries
 
-`SocialDemo/.autotap/contracts/social-system.contract.ts` is the reference system guarantee; the Scenario remains its low-level execution proof and backwards-compatible escape hatch. On 2026-08-04 the contract passed 41/41 compiled steps using two isolated contexts against one delayed shared backend. With `SOCIAL_DEMO_FAULT=hide-cross-actor-posts`, the unchanged contract failed for Bob at 19/41 and the portable merge gate exited non-zero specifically because one release contract failed.
+`SocialDemo/.tapp/contracts/social-system.contract.ts` is the reference system guarantee; the Scenario remains its low-level execution proof and backwards-compatible escape hatch. On 2026-08-04 the contract passed 41/41 compiled steps using two isolated contexts against one delayed shared backend. With `SOCIAL_DEMO_FAULT=hide-cross-actor-posts`, the unchanged contract failed for Bob at 19/41 and the portable merge gate exited non-zero specifically because one release contract failed.
 
-The fixture's `.autotap/project.json` is the central actor contract. It records Alice and Bob's
+The fixture's `.tapp/project.json` is the central actor contract. It records Alice and Bob's
 roles, isolated sessions, seeded provisioning, reset lifecycle, and four environment-variable
 names. The release contract and Scenario consume those names; neither stores the public fixture
 values. Customer values belong in the local environment or CI secret store.

package/mcp-server/src/application-model.js

@@ -8,6 +8,7 @@ import { credentialBindingsFromValue, readProjectConfig } from "./project-config
 import { applyReleaseContractCoverage, compileReleaseContract, loadReleaseContractFile, validateReleaseContractAgainstUiMap } from "./release-contract.js";
 import { applyTaskCoverage, loadTaskFile, validateTaskAgainstUiMap } from "./task-runtime.js";
 import { semanticUiKey } from "./ui-map.js";
+import { isProjectArtifactDirectory, projectArtifactDirectory } from "./project-paths.js";
 
 const SKIP = new Set([".git", ".build", ".gradle", ".next", ".swiftpm", "Pods", "Carthage", "DerivedData", "build", "dist", "node_modules", "vendor"]);
 
@@ -25,7 +26,7 @@ function walk(root, maxDepth = 4) {
     let entries;
     try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
     for (const entry of entries) {
-      if (SKIP.has(entry.name) || (entry.name.startsWith(".") && entry.name !== ".autotap")) continue;
+      if (SKIP.has(entry.name) || (entry.name.startsWith(".") && !isProjectArtifactDirectory(entry.name))) continue;
       const absolute = path.join(dir, entry.name);
       if (entry.isDirectory()) {
         directories.push(absolute);
@@ -124,7 +125,8 @@ function applyRuntimeTargetValidation(root, targets, validation) {
 }
 
 function persistedTargetValidations(root, outDir) {
-  const artifactDir = path.resolve(root, String(outDir || ".autotap"));
+  const requested = String(outDir || ".tapp");
+  const artifactDir = path.resolve(root, projectArtifactDirectory(root, requested));
   const relativeArtifactDir = path.relative(root, artifactDir);
   if (path.isAbsolute(relativeArtifactDir) || relativeArtifactDir === ".." || relativeArtifactDir.startsWith(`..${path.sep}`)) return [];
   const prior = readJson(path.join(artifactDir, "application-model.json"));
@@ -299,10 +301,11 @@ function uiMapTargetsTarget(map, target, targets) {
 }
 
 function loadTargetUiMaps(root, targets) {
-  const rootMap = loadUiMapAt(root, path.join(".autotap", "ui-map.json"));
+  const rootMap = loadUiMapAt(root, path.join(projectArtifactDirectory(root), "ui-map.json"));
   const records = targets.map((target) => {
     const scope = targetArtifactScope(target);
-    const expectedPath = posix(path.join(scope === "." ? "" : scope, ".autotap", "ui-map.json"));
+    const scopeRoot = path.join(root, scope === "." ? "" : scope);
+    const expectedPath = posix(path.join(scope === "." ? "" : scope, projectArtifactDirectory(scopeRoot), "ui-map.json"));
     let loaded = expectedPath === rootMap.summary.path ? rootMap : loadUiMapAt(root, expectedPath);
     if (!loaded.map && rootMap.map && (targets.length === 1 || uiMapTargetsTarget(rootMap.map, target, targets))) loaded = rootMap;
     return {
@@ -328,7 +331,7 @@ function loadTargetUiMaps(root, targets) {
   const prefixCoverage = unique.length > 1;
   const coverageValues = (field) => unique.flatMap((record) => (record.summary[field] || []).map((id) => prefixCoverage ? `${record.summary.targetId}:${id}` : id));
   const summary = {
-    path: unique.length === 1 ? unique[0].summary.path : ".autotap/ui-map.json",
+    path: unique.length === 1 ? unique[0].summary.path : ".tapp/ui-map.json",
     paths: unique.map((record) => record.summary.path).sort(),
     status: allObserved ? "observed" : someObserved ? "partial" : someInconclusive ? "inconclusive" : "missing",
     nodeCount: unique.reduce((total, record) => total + record.summary.nodeCount, 0),
@@ -348,14 +351,14 @@ function loadTargetUiMaps(root, targets) {
 
 function artifactScope(root, file) {
   const parts = relative(root, file).split("/");
-  const index = parts.indexOf(".autotap");
+  const index = parts.findIndex(isProjectArtifactDirectory);
   return index > 0 ? parts.slice(0, index).join("/") : ".";
 }
 
 function artifactFiles(root, inventory, kind, pattern) {
   return inventory.files.filter((file) => {
     const parts = relative(root, file).split("/");
-    const index = parts.indexOf(".autotap");
+    const index = parts.findIndex(isProjectArtifactDirectory);
     return index >= 0 && parts[index + 1] === kind && pattern.test(path.basename(file));
   }).sort();
 }
@@ -421,7 +424,7 @@ function applicationName(root, targets) {
   return pkg?.name || (targets.length === 1 ? targets[0].name : path.basename(root));
 }
 
-export async function inspectApplicationRepository({ projectDir, ownedUrl = "", platform = "", targetValidation = null, outDir = ".autotap" } = {}) {
+export async function inspectApplicationRepository({ projectDir, ownedUrl = "", platform = "", targetValidation = null, outDir = ".tapp" } = {}) {
   const root = fs.realpathSync(path.resolve(projectDir || process.cwd()));
   const inventory = walk(root);
   let targets = [
@@ -550,7 +553,7 @@ export async function inspectApplicationRepository({ projectDir, ownedUrl = "",
     requirements.push({
       id: targets.length <= 1 ? "ui-map" : `${target.id}:ui-map`, severity: "blocking", status: summary.status === "inconclusive" ? "inconclusive" : "missing",
       message: target ? (summary.status === "inconclusive" ? `The UI Map for ${target.name} is inconclusive.` : `No grounded UI Map exists for ${target.name}.`) : "No repository UI Map has been grounded in a real run.",
-      remediation: target ? `Build/launch ${target.name}, explore the real target, and retain its map at ${summary.expectedPath || summary.path}.` : "Build/launch the target and run tapp init --explore so real exploration evidence is merged into .autotap/ui-map.json.",
+      remediation: target ? `Build/launch ${target.name}, explore the real target, and retain its map at ${summary.expectedPath || summary.path}.` : "Build/launch the target and run tapp init --explore so real exploration evidence is merged into .tapp/ui-map.json.",
     });
   }
   if (!contracts.length) requirements.push({ id: "contracts", severity: "warning", status: "missing", message: "No reviewed release contracts exist yet.", remediation: "Review the proposed release plan, then generate and validate a compact set of contracts." });
@@ -925,7 +928,7 @@ function invalidateGeneratedTaskFiles(root, plan) {
   for (const record of plan.generation?.generatedTasks || []) {
     if (!record.path) continue;
     const absolute = path.resolve(root, record.path);
-    const proposalRoot = path.join(root, ".autotap", "proposals", "tasks");
+    const proposalRoot = path.join(root, projectArtifactDirectory(root), "proposals", "tasks");
     if (!isInsideRoot(proposalRoot, absolute) || !fs.existsSync(absolute)) continue;
     const task = readJson(absolute);
     if (!task || task.generation?.origin !== "deterministic-ui-map") continue;
@@ -937,8 +940,8 @@ function invalidateGeneratedTaskFiles(root, plan) {
   }
 }
 
-export function writeInitArtifacts({ root, model, plan, outDir = ".autotap", refresh = false, invalidateValidation = false } = {}) {
-  const directory = path.resolve(root, outDir);
+export function writeInitArtifacts({ root, model, plan, outDir = ".tapp", refresh = false, invalidateValidation = false } = {}) {
+  const directory = path.resolve(root, projectArtifactDirectory(root, outDir));
   const modelPath = path.join(directory, "application-model.json");
   const planPath = path.join(directory, "release-plan.json");
   if (!refresh && (fs.existsSync(modelPath) || fs.existsSync(planPath))) throw new Error(`Init artifacts already exist under ${relative(root, directory)}; inspect them or rerun with --refresh to preserve reviewed decisions while updating evidence`);
@@ -1069,7 +1072,7 @@ function generatedTaskName(node, entryOnly, occupied, identity) {
   return `${base}${crypto.createHash("sha256").update(identity).digest("hex").slice(0, 6)}`;
 }
 
-function prepareMapBackedItem(item, map, existingTasks, taskDrafts, { targetId = "", mapPath = ".autotap/ui-map.json" } = {}) {
+function prepareMapBackedItem(item, map, existingTasks, taskDrafts, { targetId = "", mapPath = ".tapp/ui-map.json" } = {}) {
   const ground = (item.groundedBy || []).find((entry) => entry.type === "ui-map-node");
   if (!ground) throw new Error("Approved UI-only proposal is not grounded by a UI Map node");
   const nodes = new Map((map.nodes || []).map((node) => [node.id, node]));
@@ -1168,7 +1171,7 @@ function writeGeneratedTaskDrafts(root, taskDrafts) {
   for (const draft of [...taskDrafts.values()].sort((a, b) => a.name.localeCompare(b.name))) {
     const scopeRoot = path.resolve(root, draft.scope === "." || !draft.scope ? "" : draft.scope);
     if (!isInsideRoot(root, scopeRoot)) throw new Error(`Generated Task scope escapes repository: ${draft.scope}`);
-    const output = path.join(scopeRoot, ".autotap", "proposals", "tasks", `${kebab(draft.name)}.task.json`);
+    const output = path.join(scopeRoot, projectArtifactDirectory(scopeRoot), "proposals", "tasks", `${kebab(draft.name)}.task.json`);
     const definition = {
       kind: "task", version: 1, name: draft.name, description: draft.description,
       ...(Object.keys(draft.inputs || {}).length ? { inputs: draft.inputs } : {}),
@@ -1189,7 +1192,7 @@ function writeGeneratedTaskDrafts(root, taskDrafts) {
     }
     try {
       const task = loadTaskFile(output);
-      const mapPath = path.resolve(root, draft.mapPath || ".autotap/ui-map.json");
+      const mapPath = path.resolve(root, draft.mapPath || ".tapp/ui-map.json");
       if (!isInsideRoot(root, mapPath)) throw new Error(`Generated Task UI Map escapes repository: ${draft.mapPath}`);
       const map = readJson(mapPath);
       if (!map || map.schemaVersion !== 1) throw new Error(`Generated Task UI Map is missing or invalid: ${draft.mapPath}`);
@@ -1304,7 +1307,7 @@ export async function generateApprovedContractProposals(plan, { projectDir } = {
     let prepared = item;
     if (item.origin === "deterministic-ui-map-proposal") {
       const grounding = (item.groundedBy || []).find((entry) => entry.type === "ui-map-node");
-      const mapPath = grounding?.mapPath || ".autotap/ui-map.json";
+      const mapPath = grounding?.mapPath || ".tapp/ui-map.json";
       const absoluteMapPath = path.resolve(root, mapPath);
       const itemMap = isInsideRoot(root, absoluteMapPath) ? readJson(absoluteMapPath) : null;
       if (!itemMap || itemMap.schemaVersion !== 1) {
@@ -1329,7 +1332,7 @@ export async function generateApprovedContractProposals(plan, { projectDir } = {
     if (!prepared) continue;
     const scopeRoot = path.resolve(root, item.scope === "." || !item.scope ? "" : item.scope);
     if (scopeRoot !== root && !scopeRoot.startsWith(root + path.sep)) throw new Error(`Plan scope escapes repository: ${item.scope}`);
-    const output = path.join(scopeRoot, ".autotap", "proposals", "contracts", `${kebab(item.name)}.contract.ts`);
+    const output = path.join(scopeRoot, projectArtifactDirectory(scopeRoot), "proposals", "contracts", `${kebab(item.name)}.contract.ts`);
     const source = draftContractSource(prepared, projectConfiguration.config || {});
     if (fs.existsSync(output) && fs.readFileSync(output, "utf8") !== source) throw new Error(`Draft contract already exists with different content and was not overwritten: ${relative(root, output)}`);
     const created = !fs.existsSync(output);
@@ -1412,13 +1415,13 @@ export function recordContractProposalValidation(plan, { id = "", name = "", pla
 export function recordGeneratedTaskProposalValidation({ projectDir, item, platform, evidence = "", detail = "" } = {}) {
   if (!["ios", "android", "web"].includes(platform)) throw new Error("platform must be ios|android|web");
   const root = fs.realpathSync(path.resolve(projectDir || process.cwd()));
-  const proposalMarker = `${path.sep}.autotap${path.sep}proposals${path.sep}tasks${path.sep}`;
-  const reviewedMarker = `${path.sep}.autotap${path.sep}tasks${path.sep}`;
+  const proposalMarkers = [".tapp", ".autotap"].map((directory) => `${path.sep}${directory}${path.sep}proposals${path.sep}tasks${path.sep}`);
+  const reviewedMarkers = [".tapp", ".autotap"].map((directory) => `${path.sep}${directory}${path.sep}tasks${path.sep}`);
   const updated = [];
   for (const taskPath of item?.generation?.taskPaths || []) {
     const absolute = path.resolve(root, taskPath);
-    const proposed = isInsideRoot(root, absolute) && absolute.includes(proposalMarker);
-    const reviewed = isInsideRoot(root, absolute) && absolute.includes(reviewedMarker) && !absolute.includes(proposalMarker);
+    const proposed = isInsideRoot(root, absolute) && proposalMarkers.some((marker) => absolute.includes(marker));
+    const reviewed = isInsideRoot(root, absolute) && reviewedMarkers.some((marker) => absolute.includes(marker)) && !proposed;
     if ((!proposed && !reviewed) || !fs.existsSync(absolute)) throw new Error(`Generated Task is missing or outside Tapp Task directories: ${taskPath}`);
     const task = readJson(absolute);
     if (!task || task.kind !== "task" || task.generation?.origin !== "deterministic-ui-map") throw new Error(`Generated Task draft has invalid provenance: ${taskPath}`);
@@ -1458,10 +1461,13 @@ export function mergeGeneratedTaskProposalValidation(plan, updates = []) {
 }
 
 function promotedDestination(root, source, kind) {
-  const marker = `${path.sep}.autotap${path.sep}proposals${path.sep}${kind}${path.sep}`;
+  const marker = [".tapp", ".autotap"]
+    .map((directory) => `${path.sep}${directory}${path.sep}proposals${path.sep}${kind}${path.sep}`)
+    .find((candidate) => source.includes(candidate));
+  if (!marker) throw new Error(`Proposal ${kind.slice(0, -1)} is outside .tapp/proposals/${kind}: ${relative(root, source)}`);
   const index = source.indexOf(marker);
-  if (index < 0) throw new Error(`Proposal ${kind.slice(0, -1)} is outside .autotap/proposals/${kind}: ${relative(root, source)}`);
-  const destination = `${source.slice(0, index)}${path.sep}.autotap${path.sep}${kind}${path.sep}${source.slice(index + marker.length)}`;
+  const directory = marker.split(path.sep).filter(Boolean)[0];
+  const destination = `${source.slice(0, index)}${path.sep}${directory}${path.sep}${kind}${path.sep}${source.slice(index + marker.length)}`;
   if (!isInsideRoot(root, destination)) throw new Error(`Promotion destination escapes repository: ${destination}`);
   return destination;
 }
@@ -1480,7 +1486,7 @@ export async function promoteValidatedProposals(plan, { projectDir, ids = [] } =
 
   const mapCache = new Map();
   const mapForItem = (item) => {
-    const relativeMapPath = item.generation?.mapPath || (item.groundedBy || []).find((entry) => entry.type === "ui-map-node")?.mapPath || ".autotap/ui-map.json";
+    const relativeMapPath = item.generation?.mapPath || (item.groundedBy || []).find((entry) => entry.type === "ui-map-node")?.mapPath || ".tapp/ui-map.json";
     const absolute = path.resolve(root, relativeMapPath);
     if (!isInsideRoot(root, absolute)) throw new Error(`UI Map for '${item.name}' escapes the repository: ${relativeMapPath}`);
     if (!mapCache.has(absolute)) {
@@ -1499,7 +1505,7 @@ export async function promoteValidatedProposals(plan, { projectDir, ids = [] } =
     for (const taskPath of item.generation.taskPaths || []) {
       const source = path.resolve(root, taskPath);
       if (!fs.existsSync(source)) throw new Error(`Generated Task is missing: ${taskPath}`);
-      if (!String(source).includes(`${path.sep}.autotap${path.sep}proposals${path.sep}tasks${path.sep}`)) continue;
+      if (![".tapp", ".autotap"].some((directory) => String(source).includes(`${path.sep}${directory}${path.sep}proposals${path.sep}tasks${path.sep}`))) continue;
       const destination = promotedDestination(root, source, "tasks");
       moves.set(source, destination);
       let task = taskRecords.get(source);

package/mcp-server/src/browser-product.js

@@ -109,7 +109,7 @@ function assetPath(pathname) {
 }
 
 function captureRoot() {
-  return path.join(process.env.AUTOTAP_HOME || process.env.TAPP_HOME || path.join(os.homedir(), ".tapp"), "captures");
+  return path.join(process.env.TAPP_HOME || process.env.AUTOTAP_HOME || path.join(os.homedir(), ".tapp"), "captures");
 }
 
 function capturePath(captureId, relative = "report.html") {

package/mcp-server/src/ci-report.js

@@ -31,6 +31,7 @@ import { writeHtmlReport } from "./html-report.js";
 import { buildUiMapFromMarkers, writeUiMap } from "./ui-map.js";
 import { proposeSelectorMaintenance, validateWebMaintenanceProposal } from "./maintenance-proposal.js";
 import { isBusinessUiMapNode, releasePlanCandidateFromUiMapNode } from "./application-model.js";
+import { existingProjectArtifactPath } from "./project-paths.js";
 
 function parseArgs(argv) {
   const args = { flowLogs: [], failOn: "gate" };
@@ -201,14 +202,14 @@ function targetCoverageDisposition(target, currentNode, projectDir = "") {
     provenance: "runtime-observed",
   });
   if (projectDir) {
-    const releasePlanPath = path.join(path.resolve(projectDir), ".autotap", "release-plan.json");
+    const releasePlanPath = existingProjectArtifactPath(path.resolve(projectDir), "release-plan.json");
     try {
       const releasePlan = JSON.parse(fs.readFileSync(releasePlanPath, "utf8"));
       const existing = (releasePlan.items || []).find((candidate) => candidate.id === item.id || candidate.name === item.name ||
         (candidate.groundedBy || []).some((ground) => ground.type === "ui-map-node" && ground.id === currentNode.id));
       if (existing) return {
         existingReleasePlanItem: {
-          path: ".autotap/release-plan.json",
+          path: ".tapp/release-plan.json",
           id: existing.id,
           name: existing.name,
           decision: existing.decision,
@@ -219,7 +220,7 @@ function targetCoverageDisposition(target, currentNode, projectDir = "") {
           kind: "release-plan-item-proposal",
           status: "matches-existing-release-plan",
           autoApply: false,
-          targetPath: ".autotap/release-plan.json",
+          targetPath: ".tapp/release-plan.json",
           operation: { op: "reconcile-item", item },
           reason: "Fresh PR runtime and changed-file evidence can be attached to the existing grounded item only through explicit adoption; its current human decision is preserved.",
           requiredValidation: "After explicit evidence reconciliation, keep the normal review, generation, deterministic replay, and promotion requirements.",
@@ -231,7 +232,7 @@ function targetCoverageDisposition(target, currentNode, projectDir = "") {
     kind: "release-plan-item-proposal",
     status: "awaiting-explicit-adoption",
     autoApply: false,
-    targetPath: ".autotap/release-plan.json",
+    targetPath: ".tapp/release-plan.json",
     operation: { op: "add-item", item },
     reason: `The changed ${currentNode.name} surface was observed in this PR run but is not covered by a selected release contract.`,
     requiredValidation: "Explicitly adopt and review this item, generate reusable UI-Map-backed Tasks, then replay the resulting contract against the real target before promotion.",

package/mcp-server/src/ci-setup.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { existingProjectArtifactPath, projectArtifactDirectory } from "./project-paths.js";
 
 function inside(root, candidate) {
   const value = path.relative(root, candidate);
@@ -36,7 +37,12 @@ export function selectApplicationTarget(model, { platform = "", target = "" } =
 
 export function baselinePathForTarget(projectDir, target) {
   const root = fs.realpathSync(path.resolve(projectDir));
-  return path.join(root, ".autotap", "baselines", target.platform, `${targetSlug(target.id)}.json`);
+  return path.join(root, ".tapp", "baselines", target.platform, `${targetSlug(target.id)}.json`);
+}
+
+export function existingBaselinePathForTarget(projectDir, target) {
+  const root = fs.realpathSync(path.resolve(projectDir));
+  return existingProjectArtifactPath(root, "baselines", target.platform, `${targetSlug(target.id)}.json`);
 }
 
 export function validateBaselineReport(report, { platform, targetId } = {}) {
@@ -134,8 +140,11 @@ function posix(value) {
 }
 
 function suiteDirectories(root, target, kind) {
-  const candidates = [path.join(root, ".autotap", kind)];
-  if (target.sourcePath && target.sourcePath !== ".") candidates.push(path.join(root, target.sourcePath, ".autotap", kind));
+  const candidates = [path.join(root, projectArtifactDirectory(root), kind)];
+  if (target.sourcePath && target.sourcePath !== ".") {
+    const targetRoot = path.join(root, target.sourcePath);
+    candidates.push(path.join(targetRoot, projectArtifactDirectory(targetRoot), kind));
+  }
   return [...new Set(candidates)].filter((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isDirectory())
     .map((candidate) => `${posix(path.relative(root, candidate))}/*.yml`);
 }
@@ -176,7 +185,7 @@ function credentialConfiguration(model, targetContracts = []) {
     if (requirements.has("email")) bindings.add("TAPP_TEST_EMAIL");
     if (requirements.has("password")) bindings.add("TAPP_TEST_PASSWORD");
   }
-  for (const name of bindings) if (!/^[A-Z_][A-Z0-9_]{0,127}$/.test(String(name))) throw new Error(`Actor credential binding '${name}' is not a safe environment-variable name; rerun tapp init from valid .autotap/project.json`);
+  for (const name of bindings) if (!/^[A-Z_][A-Z0-9_]{0,127}$/.test(String(name))) throw new Error(`Actor credential binding '${name}' is not a safe environment-variable name; rerun tapp init from valid .tapp/project.json`);
   const inputs = {};
   const primaryEmail = primary.credentialBindings?.email || (!primary.credentialBindings && requirements.has("email") ? "TAPP_TEST_EMAIL" : "");
   const primaryPassword = primary.credentialBindings?.password || (!primary.credentialBindings && requirements.has("password") ? "TAPP_TEST_PASSWORD" : "");
@@ -220,7 +229,7 @@ function targetInputs(root, model, target) {
   if (flows.length) inputs.flows = flows.join(" ");
   if (scenarios.length) inputs.scenarios = scenarios.join(" ");
   if (contracts.length) inputs.contracts = contracts.join(" ");
-  const baselinePath = baselinePathForTarget(root, target);
+  const baselinePath = existingBaselinePathForTarget(root, target);
   if (fs.existsSync(baselinePath)) inputs.baseline = posix(path.relative(root, baselinePath));
   const credentials = credentialConfiguration(model, targetContracts);
   Object.assign(inputs, credentials.inputs);
@@ -292,7 +301,7 @@ export function renderGithubWorkflow({ projectDir, model, actionRef, defaultBran
     jobs.push(lines.join("\n"));
   }
   const workflow = [
-    "# Generated by `tapp ci install` from .autotap/application-model.json.",
+    "# Generated by `tapp ci install` from .tapp/application-model.json.",
     "# Review this patch. Tapp never overwrites it silently.",
     "name: Tapp release gate",
     "",
@@ -341,7 +350,7 @@ export function renderGithubWorkflow({ projectDir, model, actionRef, defaultBran
   return { workflow, manifest };
 }
 
-export function writeCiInstallation({ projectDir, workflow, manifest, workflowPath = ".github/workflows/tapp.yml", manifestPath = ".autotap/ci.json", replace = false } = {}) {
+export function writeCiInstallation({ projectDir, workflow, manifest, workflowPath = ".github/workflows/tapp.yml", manifestPath = ".tapp/ci.json", replace = false } = {}) {
   const root = fs.realpathSync(path.resolve(projectDir || process.cwd()));
   const destinations = [path.resolve(root, workflowPath), path.resolve(root, manifestPath)];
   for (const destination of destinations) if (!inside(root, destination)) throw new Error("CI installation outputs must remain inside the repository");

package/mcp-server/src/enrich.js

@@ -40,7 +40,7 @@ export async function enrichFindings(findings, { backend, callModel, screens = [
         `Title: ${f.title}`;
       try {
         const res = await Promise.race([
-          callModel(backend, { system, userText, model: process.env.AUTOTAP_FINDING_MODEL || "claude-haiku-4-5-20251001", maxTokens: 300 }),
+          callModel(backend, { system, userText, model: process.env.TAPP_FINDING_MODEL || process.env.AUTOTAP_FINDING_MODEL || "claude-haiku-4-5-20251001", maxTokens: 300 }),
           new Promise((r) => setTimeout(() => r({ error: "timeout" }), TIMEOUT_MS)),
         ]);
         const parsed = res && !res.error ? parseEnrichment(res.text) : null;