@aarwitz/tapp 0.17.0-rc.10 → 0.17.0-rc.11

package/AGENTS.md

@@ -22,8 +22,10 @@ npx -y @aarwitz/tapp flow run .tapp/flows/smoke.yml  # committed, keyless E2E re
 ```
 
 If repository onboarding detects multiple application targets, target detection is deterministic but
-the choice is the user's. In a human TTY, Tapp displays a numbered selector and continues in the same
-command. A non-interactive CLI prints the exact choices and exits before building. MCP returns
+the choice is the user's. Explicit `init --explore` asks even when the model has a saved default; a
+later bare `explore` may consume that default. In a human TTY, Tapp displays a numbered selector and
+continues in the same command. A non-interactive CLI prints the exact choices and exits before
+building. MCP returns
 `reason: "target-selection-required"` with structured `choices[]` (`platform`, `name`, `sourcePath`,
 `selector`, and exact `command`). **Do not pick one yourself.** Present those choices to the user
 with the client's native multiple-choice question UI when available, then rerun using the selected

package/README.md

@@ -80,11 +80,14 @@ npx -y @aarwitz/tapp baseline create . --platform web
 npx -y @aarwitz/tapp ci install .
 ```
 
-On a fresh repository containing multiple apps (for example, iOS plus web), bare
-`tapp init . --explore` does not guess from detection order. A human terminal gets a numbered
+In a repository containing multiple apps (for example, iOS plus web),
+`tapp init . --explore` without an explicit target does not guess from detection order—even when a
+prior choice is recorded. A human terminal gets a numbered
 selector; a non-interactive CLI prints exact target-selection commands, while MCP also returns
 structured choices. Neither builds or writes before the choice. After you choose one, the model
-retains every detected target and records the choice as the default for the next bare `tapp explore`.
+retains every detected target and records the choice as the default for the next bare `tapp explore`;
+explicit `init --explore` continues to ask because it is the onboarding/refresh operation. Setup gaps
+belonging only to unselected targets are shown as informational, not as failures of the selected run.
 
 The baseline command writes only after exploration and every selected deterministic suite pass
 conclusively. It stores `.tapp/baselines/<platform>/<target-id>.json`; the generated workflow

package/bin/tapp.js

@@ -387,17 +387,29 @@ switch (command) {
     if (typeof flags["json-out"] === "string") {
       const out = path.resolve(flags["json-out"]);
       fs.mkdirSync(path.dirname(out), { recursive: true });
-      fs.writeFileSync(out, JSON.stringify({ model: built.model, plan: written?.plan || built.plan, ...(exploration ? { exploration } : {}) }, null, 2) + "\n");
-    }
-    const blocking = built.model.requirements.filter((item) => item.severity === "blocking");
+      fs.writeFileSync(out, JSON.stringify({
+        model: built.model,
+        plan: written?.plan || built.plan,
+        ...(exploration ? { exploration } : {}),
+        ...(result.selectedTarget ? { selectedTarget: result.selectedTarget } : {}),
+        requirementScope: result.requirementScope,
+      }, null, 2) + "\n");
+    }
+    const activeRequirements = result.requirementScope?.active || built.model.requirements;
+    const deferredRequirements = result.requirementScope?.deferred || [];
+    const blocking = activeRequirements.filter((item) => item.severity === "blocking");
+    const deferredBlocking = deferredRequirements.filter((item) => item.severity === "blocking");
     const pending = (written?.plan || built.plan).items.filter((item) => item.decision === "pending");
     console.log(`🧭 Tapp init — ${built.model.application.name}`);
     console.log(`   targets: ${built.model.targets.length ? built.model.targets.map((target) => `${target.platform}:${target.name}`).join(", ") : "none"}`);
     console.log(`   UI Map: ${built.model.uiMap.status} · ${built.model.uiMap.nodeCount} states · ${built.model.uiMap.edgeCount} transitions`);
     if (exploration) console.log(`   Exploration: ${(exploration.findings || []).length} finding(s)${exploration.inconclusive ? " (inconclusive)" : ""} · ${exploration.uiMap.nodeCount} states · evidence: ${exploration.reportHtml || exploration.capture?.path || "capture recorded"}`);
     if (exploration?.managedRuntime) console.log(`   Managed web runtime: built/started ${exploration.target} for exploration and stopped it afterward · log: ${exploration.runtime.logPath}`);
-    console.log(`   release plan: ${(written?.plan || built.plan).items.length} item(s) · ${pending.length} pending review · ${blocking.length} blocking requirement(s)`);
-    for (const requirement of built.model.requirements) console.log(`   ${requirement.severity === "blocking" ? "❌" : "⚠️"} ${requirement.message} Next: ${requirement.remediation}`);
+    const selectedLabel = result.selectedTarget ? ` for ${result.selectedTarget.platform}:${result.selectedTarget.name}` : "";
+    const deferredLabel = deferredBlocking.length ? ` · ${deferredBlocking.length} setup gap(s) on unselected target(s)` : "";
+    console.log(`   release plan: ${(written?.plan || built.plan).items.length} item(s) · ${pending.length} pending review · ${blocking.length} blocking requirement(s)${selectedLabel}${deferredLabel}`);
+    for (const requirement of activeRequirements) console.log(`   ${requirement.severity === "blocking" ? "❌" : "⚠️"} ${requirement.message} Next: ${requirement.remediation}`);
+    for (const requirement of deferredRequirements) console.log(`   ℹ️ Unselected ${requirement.targetPlatform}:${requirement.targetName} setup gap: ${requirement.message} Next: ${requirement.remediation}`);
     if (written) console.log(`   model: ${written.modelPath}\n   plan: ${written.planPath}`);
     else console.log("   dry run: repository files were not changed");
     break;

package/docs/application-model.md

@@ -16,12 +16,14 @@ resolution actually builds and installs the detected Xcode container, the model
 scheme as runtime-observed validation and removes the corresponding confirmation blocker. Merely
 supplying a bundle id or prebuilt `.app` does not prove repository build configuration.
 
-A fresh repository with more than one detected application target is never resolved by detection
-order. Bare `tapp init . --explore` prompts in a human TTY; non-interactive CLI/MCP callers receive
+A repository with more than one detected application target is never resolved by detection order
+during explicit initialization, even when a prior default exists. Bare `tapp init . --explore`
+prompts in a human TTY; non-interactive CLI/MCP callers receive
 exact `--platform`/`--target` commands before any build or write, and MCP also carries them as
 structured `target-selection-required` choices. The selected run records that target as the default
-for later bare exploration, but the application model retains the repository's other detected targets
-and their unmet coverage.
+for later bare `tapp explore`, but the application model retains the repository's other detected
+targets and their unmet coverage. The selected init run reports other-target setup gaps as deferred
+information rather than presenting them as failures of the target that was actually explored.
 
 ## First inspection
 

package/mcp-server/src/index.js

@@ -3067,11 +3067,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           server.notification({ method: "notifications/progress", params: { progressToken, progress: progress.action || 0, total: progress.max || budget, message: `Import exploration · ${progress.states} state(s) reached` } }).catch(() => {});
         },
       });
-      const { model, plan, written, exploration } = result;
-      const blocking = model.requirements.filter((item) => item.severity === "blocking");
+      const { model, plan, written, exploration, selectedTarget, requirementScope } = result;
+      const blocking = (requirementScope?.active || model.requirements).filter((item) => item.severity === "blocking");
+      const deferredBlocking = (requirementScope?.deferred || []).filter((item) => item.severity === "blocking");
       const pending = plan.items.filter((item) => item.decision === "pending");
-      const summary = `🧭 Tapp init — ${model.application.name} · ${model.targets.length} target(s) · UI Map ${model.uiMap.status} (${model.uiMap.nodeCount} states/${model.uiMap.edgeCount} transitions) · ${plan.items.length} plan item(s), ${pending.length} pending · ${blocking.length} blocking requirement(s)${exploration ? ` · real ${exploration.platform} exploration: ${(exploration.findings || []).length} finding(s)${exploration.inconclusive ? " (inconclusive)" : ""}` : ""}`;
-      return richResult(summary, { model, plan, written: written ? { modelPath: written.modelPath, planPath: written.planPath } : null, exploration });
+      const selectedLabel = selectedTarget ? ` for ${selectedTarget.platform}:${selectedTarget.name}` : "";
+      const deferredLabel = deferredBlocking.length ? ` · ${deferredBlocking.length} setup gap(s) on unselected target(s)` : "";
+      const summary = `🧭 Tapp init — ${model.application.name} · ${model.targets.length} target(s) · UI Map ${model.uiMap.status} (${model.uiMap.nodeCount} states/${model.uiMap.edgeCount} transitions) · ${plan.items.length} plan item(s), ${pending.length} pending · ${blocking.length} blocking requirement(s)${selectedLabel}${deferredLabel}${exploration ? ` · real ${exploration.platform} exploration: ${(exploration.findings || []).length} finding(s)${exploration.inconclusive ? " (inconclusive)" : ""}` : ""}`;
+      return richResult(summary, { model, plan, selectedTarget, requirementScope, written: written ? { modelPath: written.modelPath, planPath: written.planPath } : null, exploration });
     } catch (error) {
       const detail = error.message || String(error);
       const message = error.details?.reason === "target-selection-required"

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

@@ -88,7 +88,6 @@ function selectInitExplorationTarget(model, {
   platform = "",
   target = "",
   appId = "",
-  priorDefaultTargetId = "",
 } = {}) {
   const selectedPlatform = String(platform || "").trim().toLowerCase();
   if (selectedPlatform && !["ios", "android", "web"].includes(selectedPlatform)) throw new Error("platform must be ios|android|web");
@@ -97,15 +96,13 @@ function selectInitExplorationTarget(model, {
     const androidMatch = (model.targets || []).find((candidate) => candidate.platform === "android" && candidate.runtime?.applicationId === appId);
     if (androidMatch) requested = androidMatch.id;
   }
-  const defaultTargetId = (model.targets || []).some((candidate) => candidate.id === priorDefaultTargetId)
-    ? priorDefaultTargetId
-    : model.application?.defaultTargetId || "";
-  const resolutionModel = { ...model, application: { ...(model.application || {}), defaultTargetId } };
   try {
-    return selectApplicationTarget(resolutionModel, {
+    return selectApplicationTarget(model, {
       platform: selectedPlatform,
       target: requested,
-      useDefault: !selectedPlatform && !requested && !!defaultTargetId,
+      // `init --explore` is the explicit onboarding/refresh operation: it asks whenever several
+      // targets are plausible. Only a later bare `tapp explore` consumes the recorded default.
+      useDefault: false,
     });
   } catch (error) {
     const choices = initTargetChoices(model, selectedPlatform);
@@ -133,6 +130,24 @@ function selectInitExplorationTarget(model, {
   }
 }
 
+export function scopeProductRequirements(model, { selectedTargetId = "" } = {}) {
+  const targets = Array.isArray(model?.targets) ? model.targets : [];
+  const requirements = Array.isArray(model?.requirements) ? model.requirements : [];
+  const selected = String(selectedTargetId || "").trim();
+  const enriched = requirements.map((requirement) => {
+    const target = targets.find((candidate) => requirement.targetId === candidate.id || String(requirement.id || "").startsWith(`${candidate.id}:`));
+    return target
+      ? { ...requirement, targetId: target.id, targetPlatform: target.platform, targetName: target.name }
+      : { ...requirement };
+  });
+  if (!selected) return { selectedTargetId: "", active: enriched, deferred: [] };
+  return {
+    selectedTargetId: selected,
+    active: enriched.filter((requirement) => !requirement.targetId || requirement.targetId === selected),
+    deferred: enriched.filter((requirement) => requirement.targetId && requirement.targetId !== selected),
+  };
+}
+
 function productRunRoot(root) {
   const home = process.env.TAPP_HOME || path.join(os.homedir(), ".tapp");
   const identity = crypto.createHash("sha256").update(root).digest("hex").slice(0, 16);
@@ -374,7 +389,6 @@ export async function initializeProductProject({
       platform: selectedPlatform,
       target,
       appId,
-      priorDefaultTargetId: priorModel?.application?.defaultTargetId || "",
     });
     const sourceTarget = selectedTarget.sourcePath === "." ? root : path.resolve(root, selectedTarget.sourcePath);
     exploration = await runExploration({
@@ -406,7 +420,8 @@ export async function initializeProductProject({
       invalidateValidation: mode === "explore",
     });
   }
-  return { operation: "initialize", mode, model: built.model, plan: written?.plan || built.plan, exploration, written, project: readProductProject({ projectDir: root, outDir }) };
+  const requirementScope = scopeProductRequirements(built.model, { selectedTargetId: selectedTarget?.id || "" });
+  return { operation: "initialize", mode, model: built.model, plan: written?.plan || built.plan, exploration, selectedTarget, requirementScope, written, project: readProductProject({ projectDir: root, outDir }) };
 }
 
 function resolvePlan(root, outDir, planPath = "") {

package/package.json

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