@aarwitz/tapp 0.15.1 → 0.16.0

package/mcp-server/src/pr-selection.js

@@ -8,6 +8,7 @@ import crypto from "node:crypto";
 import { loadReleaseContractFile } from "./release-contract.js";
 import { loadTaskRegistry } from "./task-runtime.js";
 import { replayableUiMapNavigation, semanticUiKey } from "./ui-map.js";
+import { existingProjectArtifactPath, isProjectArtifactDirectory } from "./project-paths.js";
 
 function posix(value) {
   return String(value || "").replaceAll("\\", "/").replace(/^\.\//, "").replace(/^\/+/, "");
@@ -28,8 +29,8 @@ export function sourcePathMatches(changedFile, ownershipPath) {
 function repoRootFor(sourcePath) {
   let current = path.dirname(path.resolve(sourcePath));
   while (current !== path.dirname(current)) {
-    if (path.basename(current) === ".autotap") return path.dirname(current);
-    if (fs.existsSync(path.join(current, ".autotap"))) return current;
+    if (isProjectArtifactDirectory(path.basename(current))) return path.dirname(current);
+    if (fs.existsSync(existingProjectArtifactPath(current))) return current;
     current = path.dirname(current);
   }
   return process.cwd();
@@ -403,11 +404,11 @@ function mergeGroundingEvidence(existing, incoming) {
   return merged;
 }
 
-export function adoptPrCoverageProposal({ projectDir, prPlanPath, item, releasePlanPath = ".autotap/release-plan.json" } = {}) {
+export function adoptPrCoverageProposal({ projectDir, prPlanPath, item, releasePlanPath = ".tapp/release-plan.json" } = {}) {
   const root = fs.realpathSync(path.resolve(projectDir || process.cwd()));
   const source = path.resolve(prPlanPath || "");
   if (!prPlanPath || !fs.existsSync(source)) throw new Error(`PR plan not found: ${source || "(missing path)"}`);
-  const targetPath = path.resolve(root, releasePlanPath);
+  const targetPath = releasePlanPath === ".tapp/release-plan.json" ? existingProjectArtifactPath(root, "release-plan.json") : path.resolve(root, releasePlanPath);
   if (!inside(root, targetPath)) throw new Error("Release plan path must stay inside the project directory");
   if (!fs.existsSync(targetPath)) throw new Error(`Release plan not found: ${targetPath}; run tapp init first`);
   const prPlan = JSON.parse(fs.readFileSync(source, "utf8"));
@@ -423,7 +424,7 @@ export function adoptPrCoverageProposal({ projectDir, prPlanPath, item, releaseP
   const proposed = structuredClone(proposal.operation.item);
   if (proposed?.origin !== "deterministic-ui-map-proposal" || proposed?.decision !== "pending") throw new Error("Coverage proposal is not a pending UI-Map-grounded release-plan item");
   const ground = (proposed.groundedBy || []).find((entry) => entry.type === "ui-map-node");
-  const mapPath = path.join(root, ".autotap", "ui-map.json");
+  const mapPath = existingProjectArtifactPath(root, "ui-map.json");
   if (!ground || !fs.existsSync(mapPath)) throw new Error("Coverage proposal requires the repository's persistent UI Map");
   const map = JSON.parse(fs.readFileSync(mapPath, "utf8"));
   const node = (map.nodes || []).find((candidate) => candidate.id === ground.id && candidate.status !== "proposed");
@@ -583,7 +584,7 @@ export async function buildPrContractPlan({
     ...(Array.isArray(changedSymbolEvidence) ? changedSymbolEvidence : []),
   ]);
   const evidenceByFile = new Map(diffEvidence.map((item) => [item.file, item]));
-  const contractDir = path.join(root, ".autotap", "contracts");
+  const contractDir = existingProjectArtifactPath(root, "contracts");
   const discovered = discoverContracts && fs.existsSync(contractDir)
     ? fs.readdirSync(contractDir).filter((name) => /\.contract\.(?:ts|mts|mjs|js|json)$/i.test(name)).map((name) => path.join(contractDir, name)) : [];
   const files = [...new Set([...discovered, ...contractPaths.map((item) => path.resolve(root, item))])];
@@ -594,10 +595,10 @@ export async function buildPrContractPlan({
   }
 
   let tasks = new Map();
-  const registrySource = files[0] || path.join(root, ".autotap", "contracts", "contract.ts");
+  const registrySource = files[0] || existingProjectArtifactPath(root, "contracts", "contract.ts");
   try { tasks = loadTaskRegistry({ sourcePath: registrySource, projectDir: root }); } catch {}
   let map = null;
-  const resolvedMapPath = mapPath ? path.resolve(root, mapPath) : path.join(root, ".autotap", "ui-map.json");
+  const resolvedMapPath = mapPath ? path.resolve(root, mapPath) : existingProjectArtifactPath(root, "ui-map.json");
   if (fs.existsSync(resolvedMapPath)) map = JSON.parse(fs.readFileSync(resolvedMapPath, "utf8"));
 
   const impactedNodes = map ? map.nodes.filter((node) => matchedFiles(changes, node.sourcePaths || []).length) : [];

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

@@ -16,8 +16,9 @@ import {
   reviewReleasePlan,
   writeInitArtifacts,
 } from "./application-model.js";
-import { baselinePathForTarget, renderGithubWorkflow, selectApplicationTarget, writeCiInstallation, writeTargetBaseline } from "./ci-setup.js";
+import { baselinePathForTarget, existingBaselinePathForTarget, renderGithubWorkflow, selectApplicationTarget, writeCiInstallation, writeTargetBaseline } from "./ci-setup.js";
 import { executeReleaseContract, runProductProcess } from "./product-execution.js";
+import { projectArtifactDirectory } from "./project-paths.js";
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 const packageVersion = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8")).version;
@@ -50,8 +51,9 @@ function atomicJson(file, value) {
   fs.renameSync(temporary, file);
 }
 
-function artifactPaths(root, outDir = ".autotap") {
-  const dir = path.resolve(root, outDir);
+function artifactPaths(root, outDir = ".tapp") {
+  const selectedOutDir = projectArtifactDirectory(root, outDir);
+  const dir = path.resolve(root, selectedOutDir);
   if (!inside(root, dir)) throw new Error("Artifact directory must remain inside the repository");
   return {
     dir,
@@ -94,7 +96,7 @@ function listProductRuns(root) {
 }
 
 function listRepositoryFlows(root) {
-  const directory = path.join(root, ".autotap", "flows");
+  const directory = path.join(root, projectArtifactDirectory(root), "flows");
   if (!fs.existsSync(directory)) return [];
   return fs.readdirSync(directory, { withFileTypes:true })
     .filter((entry) => entry.isFile() && /\.(?:ya?ml|json)$/i.test(entry.name))
@@ -127,7 +129,7 @@ function listRepositoryFlows(root) {
     .sort((left, right) => left.path.localeCompare(right.path));
 }
 
-export function readProductProject({ projectDir, outDir = ".autotap" } = {}) {
+export function readProductProject({ projectDir, outDir = ".tapp" } = {}) {
   const root = realProject(projectDir);
   const paths = artifactPaths(root, outDir);
   const model = readJson(paths.model);
@@ -137,7 +139,7 @@ export function readProductProject({ projectDir, outDir = ".autotap" } = {}) {
   const requirements = model?.requirements || [];
   const planItems = plan?.items || [];
   const baselines = (model?.targets || []).map((target) => {
-    const file = baselinePathForTarget(root, target);
+    const file = existingBaselinePathForTarget(root, target);
     return { targetId: target.id, platform: target.platform, path: file, relativePath: path.relative(root, file).replaceAll(path.sep, "/"), exists: fs.existsSync(file) };
   });
   return {
@@ -177,7 +179,7 @@ export function readProductProject({ projectDir, outDir = ".autotap" } = {}) {
 // target identity or configuration rules.
 export async function prepareProductTarget({
   projectDir,
-  outDir = ".autotap",
+  outDir = ".tapp",
   platform = "",
   target = "",
   appPath = "",
@@ -262,7 +264,7 @@ export async function prepareProductTarget({
 export async function initializeProductProject({
   projectDir,
   mode = "inspect",
-  outDir = ".autotap",
+  outDir = ".tapp",
   ownedUrl = "",
   platform = "",
   target = "",
@@ -326,7 +328,7 @@ function resolvePlan(root, outDir, planPath = "") {
   return { file, plan: readJson(file, { required: true }) };
 }
 
-export function reviewProductPlan({ projectDir, outDir = ".autotap", planPath = "", approve = [], reject = [], defer = [] } = {}) {
+export function reviewProductPlan({ projectDir, outDir = ".tapp", planPath = "", approve = [], reject = [], defer = [] } = {}) {
   const root = realProject(projectDir);
   const resolved = resolvePlan(root, outDir, planPath);
   const plan = reviewReleasePlan(resolved.plan, { approve, reject, defer });
@@ -334,7 +336,7 @@ export function reviewProductPlan({ projectDir, outDir = ".autotap", planPath =
   return { operation: "review-plan", plan, planPath: resolved.file, project: readProductProject({ projectDir: root, outDir }) };
 }
 
-export async function generateProductPlan({ projectDir, outDir = ".autotap", planPath = "" } = {}) {
+export async function generateProductPlan({ projectDir, outDir = ".tapp", planPath = "" } = {}) {
   const root = realProject(projectDir);
   const resolved = resolvePlan(root, outDir, planPath);
   const result = await generateApprovedContractProposals(resolved.plan, { projectDir: root });
@@ -344,7 +346,7 @@ export async function generateProductPlan({ projectDir, outDir = ".autotap", pla
 
 export async function validateProductPlan({
   projectDir,
-  outDir = ".autotap",
+  outDir = ".tapp",
   planPath = "",
   items = [],
   platform = "",
@@ -411,7 +413,7 @@ export async function validateProductPlan({
   return { operation: "validate-plan", platform: selectedPlatform, passed: results.every((item) => item.passed), results, plan, planPath: resolved.file, project: readProductProject({ projectDir: root, outDir }) };
 }
 
-export async function promoteProductPlan({ projectDir, outDir = ".autotap", planPath = "", items = [] } = {}) {
+export async function promoteProductPlan({ projectDir, outDir = ".tapp", planPath = "", items = [] } = {}) {
   const root = realProject(projectDir);
   const resolved = resolvePlan(root, outDir, planPath);
   const result = await promoteValidatedProposals(resolved.plan, { projectDir: root, ids: items || [] });
@@ -423,7 +425,7 @@ export async function promoteProductPlan({ projectDir, outDir = ".autotap", plan
   return { operation: "promote-plan", ...result, plan: written.plan, planPath: written.planPath, modelPath: written.modelPath, project: readProductProject({ projectDir: root, outDir }) };
 }
 
-export function prepareProductCi({ projectDir, outDir = ".autotap", modelPath = "", actionRef = DEFAULT_ACTION_REF, defaultBranch = "main" } = {}) {
+export function prepareProductCi({ projectDir, outDir = ".tapp", modelPath = "", actionRef = DEFAULT_ACTION_REF, defaultBranch = "main" } = {}) {
   const root = realProject(projectDir);
   const modelFile = modelPath ? path.resolve(root, modelPath) : artifactPaths(root, outDir).model;
   if (!inside(root, modelFile)) throw new Error("Application model must remain inside the repository");
@@ -433,7 +435,7 @@ export function prepareProductCi({ projectDir, outDir = ".autotap", modelPath =
   return { operation: "prepare-ci", ...rendered, project: readProductProject({ projectDir: root, outDir }) };
 }
 
-export function installProductCi({ projectDir, outDir = ".autotap", modelPath = "", actionRef = DEFAULT_ACTION_REF, defaultBranch = "main", workflowPath = ".github/workflows/tapp.yml", manifestPath = ".autotap/ci.json", replace = false, allowUnresolved = false } = {}) {
+export function installProductCi({ projectDir, outDir = ".tapp", modelPath = "", actionRef = DEFAULT_ACTION_REF, defaultBranch = "main", workflowPath = ".github/workflows/tapp.yml", manifestPath = ".tapp/ci.json", replace = false, allowUnresolved = false } = {}) {
   const root = realProject(projectDir);
   const rendered = prepareProductCi({ projectDir: root, outDir, modelPath, actionRef, defaultBranch });
   if (rendered.manifest.unresolved.length && !allowUnresolved) throw new Error(`CI installation is unresolved: ${rendered.manifest.unresolved.map((item) => `${item.platform}:${item.message}`).join("; ")}`);
@@ -443,7 +445,7 @@ export function installProductCi({ projectDir, outDir = ".autotap", modelPath =
 
 export async function runProductGate({
   projectDir,
-  outDir = ".autotap",
+  outDir = ".tapp",
   platform = "web",
   target = "",
   url = "",
@@ -501,7 +503,7 @@ export async function runProductGate({
     if (!inside(root, baselinePath) || !fs.existsSync(baselinePath)) throw new Error("Baseline must be an existing file inside the repository");
     args.push("--baseline", baselinePath);
   } else {
-    const targetBaseline = baselinePathForTarget(root, selected);
+    const targetBaseline = existingBaselinePathForTarget(root, selected);
     if (fs.existsSync(targetBaseline)) args.push("--baseline", targetBaseline);
   }
   onProgress({ phase: "gate", text: `Running ${selected.platform}:${selected.name} release gate` });
@@ -515,7 +517,7 @@ export async function runProductGate({
   return { operation: "run-gate", passed: execution.code === 0, code: execution.code, stdout: execution.stdout, stderr: execution.stderr, selectedTarget: selected, report, reportPath, markdownPath, runDir, project: readProductProject({ projectDir: root, outDir }) };
 }
 
-export function createProductBaseline({ projectDir, outDir = ".autotap", reportPath, platform = "web", target = "", replace = false, baselinePath = "" } = {}) {
+export function createProductBaseline({ projectDir, outDir = ".tapp", reportPath, platform = "web", target = "", replace = false, baselinePath = "" } = {}) {
   const root = realProject(projectDir);
   const project = readProductProject({ projectDir: root, outDir });
   const selected = selectApplicationTarget(project.model, { platform, target });

package/mcp-server/src/project-config.js

@@ -1,7 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
+import { LEGACY_TAPP_DIRECTORY, TAPP_DIRECTORY, projectArtifactDirectory } from "./project-paths.js";
 
-export const PROJECT_CONFIG_RELATIVE_PATH = ".autotap/project.json";
+export const PROJECT_CONFIG_RELATIVE_PATH = `${TAPP_DIRECTORY}/project.json`;
+export const LEGACY_PROJECT_CONFIG_RELATIVE_PATH = `${LEGACY_TAPP_DIRECTORY}/project.json`;
 
 const ACTOR_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
 const ENV_NAME = /^[A-Z_][A-Z0-9_]{0,127}$/;
@@ -58,15 +60,16 @@ export function validateProjectConfig(config) {
 
 export function readProjectConfig(projectDir, { required = false } = {}) {
   const root = fs.realpathSync(path.resolve(projectDir || process.cwd()));
-  const configPath = path.join(root, PROJECT_CONFIG_RELATIVE_PATH);
+  const relativePath = `${projectArtifactDirectory(root)}/project.json`;
+  const configPath = path.join(root, relativePath);
   if (!fs.existsSync(configPath)) {
     if (required) throw new Error(`Project configuration not found: ${configPath}`);
-    return { root, path: configPath, relativePath: PROJECT_CONFIG_RELATIVE_PATH, config: { kind: "tapp-project-config", schemaVersion: 1, actors: {} }, exists: false, errors: [] };
+    return { root, path: configPath, relativePath, config: { kind: "tapp-project-config", schemaVersion: 1, actors: {} }, exists: false, errors: [] };
   }
   let config;
   try { config = JSON.parse(fs.readFileSync(configPath, "utf8")); }
-  catch (error) { return { root, path: configPath, relativePath: PROJECT_CONFIG_RELATIVE_PATH, config: null, exists: true, errors: [`Invalid JSON: ${error.message}`] }; }
-  return { root, path: configPath, relativePath: PROJECT_CONFIG_RELATIVE_PATH, config, exists: true, errors: validateProjectConfig(config) };
+  catch (error) { return { root, path: configPath, relativePath, config: null, exists: true, errors: [`Invalid JSON: ${error.message}`] }; }
+  return { root, path: configPath, relativePath, config, exists: true, errors: validateProjectConfig(config) };
 }
 
 export function configureActor(projectDir, { name, role = "", session = "default", provisioning = "existing", credentials = {}, replace = false } = {}) {

package/mcp-server/src/project-paths.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const TAPP_DIRECTORY = ".tapp";
+export const LEGACY_TAPP_DIRECTORY = ".autotap";
+export const TAPP_CONFIG = ".tapp.yml";
+export const LEGACY_TAPP_CONFIG = ".autotap.yml";
+
+export function projectArtifactDirectory(projectDir, requested = TAPP_DIRECTORY) {
+  const root = path.resolve(projectDir);
+  if (requested !== TAPP_DIRECTORY) return requested;
+  const canonical = path.join(root, TAPP_DIRECTORY);
+  const legacy = path.join(root, LEGACY_TAPP_DIRECTORY);
+  if (!fs.existsSync(canonical) && fs.existsSync(legacy)) return LEGACY_TAPP_DIRECTORY;
+  return TAPP_DIRECTORY;
+}
+
+export function projectArtifactPath(projectDir, ...parts) {
+  return path.join(path.resolve(projectDir), projectArtifactDirectory(projectDir), ...parts);
+}
+
+export function existingProjectArtifactPath(projectDir, ...parts) {
+  const root = path.resolve(projectDir);
+  const canonical = path.join(root, TAPP_DIRECTORY, ...parts);
+  if (fs.existsSync(canonical)) return canonical;
+  const legacy = path.join(root, LEGACY_TAPP_DIRECTORY, ...parts);
+  return fs.existsSync(legacy) ? legacy : canonical;
+}
+
+export function isProjectArtifactDirectory(name) {
+  return name === TAPP_DIRECTORY || name === LEGACY_TAPP_DIRECTORY;
+}

package/mcp-server/src/task-runtime.js

@@ -7,6 +7,7 @@ import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { semanticUiKey } from "./ui-map.js";
+import { isProjectArtifactDirectory, projectArtifactDirectory } from "./project-paths.js";
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 
@@ -84,12 +85,15 @@ export function loadTaskFile(taskPath) {
   return { ...task, __path: path.resolve(taskPath) };
 }
 
-function findAutotapDir(sourcePath, explicitProjectDir = "") {
-  if (explicitProjectDir) return path.join(path.resolve(explicitProjectDir), ".autotap");
+function findTappDir(sourcePath, explicitProjectDir = "") {
+  if (explicitProjectDir) {
+    const root = path.resolve(explicitProjectDir);
+    return path.join(root, projectArtifactDirectory(root));
+  }
   let current = path.dirname(path.resolve(sourcePath));
   while (current !== path.dirname(current)) {
-    if (path.basename(current) === ".autotap") return current;
-    const candidate = path.join(current, ".autotap");
+    if (isProjectArtifactDirectory(path.basename(current))) return current;
+    const candidate = path.join(current, projectArtifactDirectory(current));
     if (fs.existsSync(candidate)) return candidate;
     current = path.dirname(current);
   }
@@ -97,16 +101,16 @@ function findAutotapDir(sourcePath, explicitProjectDir = "") {
 }
 
 export function loadTaskRegistry({ sourcePath, projectDir = "", taskFiles = [] }) {
-  const autotapDir = findAutotapDir(sourcePath, projectDir);
-  const taskDir = autotapDir ? path.join(autotapDir, "tasks") : "";
+  const tappDir = findTappDir(sourcePath, projectDir);
+  const taskDir = tappDir ? path.join(tappDir, "tasks") : "";
   const reviewed = taskDir && fs.existsSync(taskDir)
     ? fs.readdirSync(taskDir).filter((name) => /\.ya?ml$|\.json$/i.test(name)).map((name) => path.join(taskDir, name))
     : [];
-  // Draft contracts generated under `.autotap/proposals/contracts` may compile
+  // Draft contracts generated under `.tapp/proposals/contracts` may compile
   // against sibling untrusted Task drafts. Ordinary committed contracts never
   // see this directory, so a proposal cannot silently enter the release gate.
-  const proposalSource = String(path.resolve(sourcePath || "")).includes(`${path.sep}.autotap${path.sep}proposals${path.sep}`);
-  const proposalDir = proposalSource && autotapDir ? path.join(autotapDir, "proposals", "tasks") : "";
+  const proposalSource = [".tapp", ".autotap"].some((directory) => String(path.resolve(sourcePath || "")).includes(`${path.sep}${directory}${path.sep}proposals${path.sep}`));
+  const proposalDir = proposalSource && tappDir ? path.join(tappDir, "proposals", "tasks") : "";
   const proposed = proposalDir && fs.existsSync(proposalDir)
     ? fs.readdirSync(proposalDir).filter((name) => /\.ya?ml$|\.json$/i.test(name)).map((name) => path.join(proposalDir, name))
     : [];
@@ -169,7 +173,7 @@ export function compileTaskSteps({ steps, registry, platform = "", flowVars = {}
     const invocation = taskCall(step);
     if (!invocation) { expanded.push(step); continue; }
     const task = registry.get(invocation.call.task);
-    if (!task) throw new Error(`Task '${invocation.call.task}' was not found in .autotap/tasks`);
+    if (!task) throw new Error(`Task '${invocation.call.task}' was not found in .tapp/tasks`);
     if (stack.includes(task.name)) throw new Error(`Task cycle detected: ${[...stack, task.name].join(" -> ")}`);
     const implementation = implementationSteps(task, platform);
     if (!implementation?.steps) throw new Error(`Task '${task.name}' has no '${platform || "shared"}' implementation`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aarwitz/tapp",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "mcpName": "io.github.aarwitz/tapp",
   "description": "Release contracts, autonomous QA, and evidence-backed CI gates for iOS, Android, and web.",
   "license": "MIT",

package/scripts/ci-gate.sh

@@ -15,9 +15,9 @@
 #                      # bundle id is detected from the .app when omitted
 #                      [--actions N]              # exploration budget (default 40)
 #                      [--timeout S]              # exploration watchdog (default 600)
-#                      [--flows <glob>]           # Flow YAMLs to replay (default: <app repo>/.autotap/flows/*.yml if --project-dir given)
-#                      [--scenarios <glob>]       # Multi-actor Scenario YAMLs (web; default: <app repo>/.autotap/scenarios/*.yml)
-#                      [--contracts <glob>]       # TypeScript release contracts (default: <app repo>/.autotap/contracts/*.contract.ts)
+#                      [--flows <glob>]           # Flow YAMLs to replay (default: <app repo>/.tapp/flows/*.yml if --project-dir given)
+#                      [--scenarios <glob>]       # Multi-actor Scenario YAMLs (web; default: <app repo>/.tapp/scenarios/*.yml)
+#                      [--contracts <glob>]       # TypeScript release contracts (default: <app repo>/.tapp/contracts/*.contract.ts)
 #                      [--project-dir <dir>]      # the app repo checkout (for flows + baseline defaults)
 #                      [--pr-base <git-ref>]      # select critical + diff-relevant contracts from base...head
 #                      [--pr-head <git-ref>]      # default HEAD
@@ -79,10 +79,15 @@ if [[ -n "$PROJECT_DIR" ]]; then
   [[ -d "$PROJECT_DIR" ]] || { echo "❌ Project directory not found: $PROJECT_DIR" >&2; exit 2; }
   PROJECT_DIR="$(cd "$PROJECT_DIR" && pwd)"
 fi
-[[ -z "$FLOWS" && -n "$PROJECT_DIR" && -d "$PROJECT_DIR/.autotap/flows" ]] && FLOWS="$PROJECT_DIR/.autotap/flows/*.yml"
-[[ "$PLATFORM" == "web" && -z "$SCENARIOS" && -n "$PROJECT_DIR" && -d "$PROJECT_DIR/.autotap/scenarios" ]] && SCENARIOS="$PROJECT_DIR/.autotap/scenarios/*.yml"
-[[ -z "$CONTRACTS" && -n "$PROJECT_DIR" && -d "$PROJECT_DIR/.autotap/contracts" ]] && CONTRACTS="$PROJECT_DIR/.autotap/contracts/*.contract.ts"
-[[ -z "$BASELINE" && -n "$PROJECT_DIR" && -f "$PROJECT_DIR/.autotap/baseline.json" ]] && BASELINE="$PROJECT_DIR/.autotap/baseline.json"
+TAPP_PROJECT_ARTIFACTS=""
+if [[ -n "$PROJECT_DIR" ]]; then
+  [[ -d "$PROJECT_DIR/.tapp" ]] && TAPP_PROJECT_ARTIFACTS="$PROJECT_DIR/.tapp"
+  [[ -z "$TAPP_PROJECT_ARTIFACTS" && -d "$PROJECT_DIR/.autotap" ]] && TAPP_PROJECT_ARTIFACTS="$PROJECT_DIR/.autotap"
+fi
+[[ -z "$FLOWS" && -n "$TAPP_PROJECT_ARTIFACTS" && -d "$TAPP_PROJECT_ARTIFACTS/flows" ]] && FLOWS="$TAPP_PROJECT_ARTIFACTS/flows/*.yml"
+[[ "$PLATFORM" == "web" && -z "$SCENARIOS" && -n "$TAPP_PROJECT_ARTIFACTS" && -d "$TAPP_PROJECT_ARTIFACTS/scenarios" ]] && SCENARIOS="$TAPP_PROJECT_ARTIFACTS/scenarios/*.yml"
+[[ -z "$CONTRACTS" && -n "$TAPP_PROJECT_ARTIFACTS" && -d "$TAPP_PROJECT_ARTIFACTS/contracts" ]] && CONTRACTS="$TAPP_PROJECT_ARTIFACTS/contracts/*.contract.ts"
+[[ -z "$BASELINE" && -n "$TAPP_PROJECT_ARTIFACTS" && -f "$TAPP_PROJECT_ARTIFACTS/baseline.json" ]] && BASELINE="$TAPP_PROJECT_ARTIFACTS/baseline.json"
 [[ -z "$BASELINE" || -f "$BASELINE" ]] || { echo "❌ Baseline not found: $BASELINE" >&2; exit 2; }
 if [[ -n "$BASELINE" ]]; then
   python3 -c 'import json,sys; json.load(open(sys.argv[1]))' "$BASELINE" 2>/dev/null \

package/scripts/flow_lib.py

@@ -23,7 +23,7 @@ def load_flow(path):
 
 
 def to_yaml(json_str):
-    """Emit a recorded/inline Flow (JSON string) as tidy YAML for saving to .autotap/flows/*.yml."""
+    """Emit a recorded/inline Flow (JSON string) as tidy YAML for saving to .tapp/flows/*.yml."""
     import yaml
     flow = json.loads(json_str)
     # Order keys for readability. `platform` + `url` make the same repository-native