meguro-mcp 0.2.13 → 0.2.14

package/src/tools.mjs

@@ -28,6 +28,7 @@ const DOCUMENTATION_TOOL_CONTRACT = documentationToolContract();
 const DOCUMENTATION_TOPICS = new Set(DOCUMENTATION_TOOL_CONTRACT.topics);
 const FLEET_TOOL_NAMES = new Set([
   'templates_list', 'template_get', 'stores_list', 'store_create', 'store_delete', 'store_passport',
+  'sample_store_reset',
   'practice_runs_list',
   'workspaces_list', 'workspace_create', 'workspace_archive', 'workspace_unarchive',
   'catalog_slice_read', 'catalog_slice_snapshot', 'catalog_slices_saved',
@@ -40,6 +41,7 @@ const TOOL_PRESENTATION = Object.freeze({
   store_create: { title: 'Create a practice store', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
   store_delete: { title: 'Delete a practice store', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
   store_passport: { title: 'Read Store Passport', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  sample_store_reset: { title: 'Repair the sample practice store', readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
   workspaces_list: { title: 'List account workspaces', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
   workspace_create: { title: 'Create a workspace', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
   workspace_archive: { title: 'Archive a workspace', readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
@@ -63,7 +65,7 @@ const TOOL_PRESENTATION = Object.freeze({
   twin_diff: { title: 'Read a twin impact receipt', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
   docs_read: { title: 'Read Meguro product and evidence documentation', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
   exam_preflight: { title: 'Check Shopify Exam readiness', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-  exam_start: { title: 'Start or continue a Shopify Exam', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+  exam_start: { title: 'Start or continue a Shopify Exam', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
   exam_status: { title: 'Read Shopify Exam status', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
   exam_report: { title: 'Read a Shopify Exam receipt', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
   practice_run_start: { title: 'Start a practice run', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
@@ -72,7 +74,7 @@ const TOOL_PRESENTATION = Object.freeze({
   practice_run_checkpoint: { title: 'Capture a practice-run checkpoint', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
   practice_run_advance: { title: 'Advance store time', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
   practice_run_finish: { title: 'Finish a practice run', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-  practice_run_report: { title: 'Read a compatibility receipt', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  practice_run_report: { title: 'Read a practice-run receipt', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
   practice_run_impact: { title: 'Read a practice-run impact receipt', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
   get_connection_details: { title: 'Get practice-store connection details', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
   admin_probe: { title: 'Run an Admin API probe', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
@@ -204,7 +206,42 @@ function storeDeletePreviewProjection(value) {
   const safe = secretSafe(value);
   if (!safe || typeof safe !== 'object' || typeof value?.confirmToken !== 'string') return safe;
   const confirmToken = value.confirmToken.trim();
-  return /^mcpdel_[A-Za-z0-9_-]{20,128}$/u.test(confirmToken) ? { ...safe, confirmToken } : safe;
+  if (!/^mcpdel_[A-Za-z0-9_-]{20,128}$/u.test(confirmToken)) return safe;
+  const nextStep = value?.nextStep;
+  const calls = Array.isArray(nextStep?.validNextCalls) ? nextStep.validNextCalls : [];
+  const confirmationCall = calls.length === 1 ? calls[0] : null;
+  const confirmationArguments = confirmationCall?.arguments;
+  const workspaceId = typeof confirmationArguments?.workspaceId === 'string'
+    && /^[a-z0-9][a-z0-9-]{0,127}$/u.test(confirmationArguments.workspaceId)
+    ? confirmationArguments.workspaceId
+    : undefined;
+  const projectedNextStep = nextStep?.schemaVersion === 'meguro.admin-execution-next-step.v1'
+    && Number.isInteger(nextStep.order)
+    && typeof nextStep.id === 'string'
+    && ['required', 'ready', 'blocked'].includes(nextStep.status)
+    && confirmationCall?.plane === 'mcp-control'
+    && confirmationCall.tool === 'store_delete'
+    && typeof confirmationCall.purpose === 'string'
+    && typeof confirmationArguments?.storeId === 'string'
+    && confirmationArguments.confirmToken === confirmToken
+    ? {
+        schemaVersion: nextStep.schemaVersion,
+        order: nextStep.order,
+        id: nextStep.id,
+        status: nextStep.status,
+        validNextCalls: [{
+          plane: 'mcp-control',
+          tool: 'store_delete',
+          arguments: {
+            storeId: confirmationArguments.storeId,
+            confirmToken,
+            ...(workspaceId ? { workspaceId } : {}),
+          },
+          purpose: confirmationCall.purpose,
+        }],
+      }
+    : undefined;
+  return { ...safe, confirmToken, ...(projectedNextStep ? { nextStep: projectedNextStep } : {}) };
 }
 
 // A catalog snapshot token is the explicit output capability of the snapshot routes: Console passes
@@ -315,6 +352,9 @@ function storeTemplateDetailProjection(value) {
     storeTemplate: Object.fromEntries(STORE_TEMPLATE_FIELDS
       .filter((field) => Object.hasOwn(storeTemplate, field))
       .map((field) => [field, secretSafe(storeTemplate[field], 1)])),
+    ...(value?.nextStep && typeof value.nextStep === 'object'
+      ? { nextStep: secretSafe(value.nextStep, 1) }
+      : {}),
   };
 }
 
@@ -471,6 +511,42 @@ function storeTemplatesProjection(value) {
       ...(recommendationUnavailable ? { recommendationUnavailable } : {}),
     },
     storeTemplates,
+    ...(value?.nextStep && typeof value.nextStep === 'object'
+      ? { nextStep: secretSafe(value.nextStep, 1) }
+      : {}),
+  };
+}
+
+/**
+ * Anonymous catalog callers do not have an account whose tier or current metering allowance can
+ * truthfully be named. Keep this as the one exclusion authority for the anonymous projection so a
+ * new account-derived plan field fails visibly into the authenticated shape until it is classified
+ * here, rather than being removed by scattered response rewrites.
+ */
+const ANONYMOUS_TEMPLATE_ACCOUNT_FIELDS = Object.freeze([
+  'tier',
+  'authorization',
+  'usage',
+  'runStartAllowed',
+  'runStartAllowedMeaning',
+  'runStartAllowance',
+  'remainingSimulationRuns',
+  'remainingAuthorizedDaysAfterFirstSegment',
+]);
+const ANONYMOUS_ACCOUNT_ALLOWANCES = 'Account-specific allowances appear after sign-in.';
+
+function withoutAnonymousTemplateAccountFields(value) {
+  if (Array.isArray(value)) return value.map(withoutAnonymousTemplateAccountFields);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.entries(value)
+    .filter(([field]) => !ANONYMOUS_TEMPLATE_ACCOUNT_FIELDS.includes(field))
+    .map(([field, child]) => [field, withoutAnonymousTemplateAccountFields(child)]));
+}
+
+function anonymousStoreTemplatesProjection(value) {
+  return {
+    ...withoutAnonymousTemplateAccountFields(storeTemplatesProjection(value)),
+    accountAllowances: ANONYMOUS_ACCOUNT_ALLOWANCES,
   };
 }
 
@@ -505,7 +581,12 @@ function practiceErrorResult(status, value, retryAfterSeconds, teaching, declare
   if (Number.isFinite(retryAfterSeconds) && retryAfterSeconds >= 0) stable.retryAfterSeconds = retryAfterSeconds;
   else if (Number.isFinite(bodyRetryAfter) && bodyRetryAfter >= 0) stable.retryAfterSeconds = bodyRetryAfter;
   if (typeof body.retryable === 'boolean') stable.retryable = body.retryable;
-  if (teaching) stable.teaching = secretSafe(teaching);
+  const routeTeaching = body.teaching && typeof body.teaching === 'object' ? body.teaching : undefined;
+  if (teaching ?? routeTeaching) stable.teaching = secretSafe(teaching ?? routeTeaching);
+  if (Array.isArray(body.validNextCalls)) stable.validNextCalls = secretSafe(body.validNextCalls);
+  const briefField = railBrief(body.brief);
+  if (briefField.brief !== undefined) stable.brief = secretSafe(briefField.brief);
+  if (body.nextStep && typeof body.nextStep === 'object') stable.nextStep = secretSafe(body.nextStep);
   const result = { content: [{ type: 'text', text: JSON.stringify(stable, null, 2) }], isError: true };
   // MEG-1057: an attempt-identity 404 is pre-commit by construction — nothing can have applied
   // against an attempt that does not exist. Without this the mutating routes fell through to the
@@ -520,7 +601,7 @@ function practiceErrorResult(status, value, retryAfterSeconds, teaching, declare
 
 function practiceRunUnavailableTeaching(toolName, attemptId) {
   return {
-    meaning: `No practice simulation attempt with attemptId ${attemptId} is available to this account. ${toolName} accepts only a pa-* attemptId returned by practice_run_start.`,
+    meaning: `No practice simulation run with attemptId ${attemptId} is available to this account. ${toolName} accepts only a pa-* attemptId returned by practice_run_start.`,
     nextStep: `Call stores_list({}), choose an exact current storeId, call practice_run_start({ storeId: "<exact storeId>" }), use the returned attemptId, then call ${toolName}({ attemptId: "<returned attemptId>" }).`,
     stopCondition: `If stores_list({}) returns no usable practice store, stop. Do not retry the unavailable attemptId ${attemptId}.`,
   };
@@ -566,6 +647,17 @@ function validatedStoreId(value, key) {
   return value;
 }
 
+/**
+ * MEG-1571: `detail` selects the bounded receipt comparison card (default) or the full document.
+ * An unknown value fails closed here rather than reaching the API as a silent card request.
+ */
+function requiredReceiptDetail(args) {
+  const detail = args?.detail;
+  if (detail === undefined) return 'card';
+  if (detail !== 'card' && detail !== 'full') throw new Error("detail must be 'card' or 'full'");
+  return detail;
+}
+
 function optionalWorkspaceId(args) {
   if (args?.workspaceId === undefined) return undefined;
   const workspaceId = requiredString(args, 'workspaceId');
@@ -631,6 +723,8 @@ const CATALOG_SNAPSHOT_INPUT_PROPERTIES = Object.freeze({
 const CATALOG_SAVED_SLICES_INPUT_PROPERTIES = Object.freeze({
   workspaceId: { type: 'string', minLength: 1, description: 'Optional account-owned workspace selector. Omit for Default.' },
   action: { type: 'string', enum: ['list', 'get', 'save', 'delete', 'refresh', 'changes'] },
+  limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Maximum saved catalog-slice rows in this page. Defaults to 100 for action=list.' },
+  cursor: { type: 'string', minLength: 1, description: 'Opaque nextCursor returned by the preceding action=list page.' },
   shopDomain: { type: 'string', pattern: '^[a-z0-9][a-z0-9-]*\\.myshopify\\.com$', description: 'Required for save.' },
   label: { type: 'string', minLength: 1, maxLength: 80, description: 'Required for save.' },
   variantIds: { type: 'array', minItems: 1, maxItems: 25, items: { type: 'string', minLength: 1 }, description: 'Required for save.' },
@@ -699,7 +793,7 @@ const CATALOG_SAVED_SLICES_BRANCHES = Object.freeze([
     action: 'save',
     mutates: true,
     required: ['action', 'shopDomain', 'label', 'variantIds'],
-    forbidden: ['sliceId'],
+    forbidden: ['limit', 'cursor', 'sliceId'],
     example: {
       action: 'save',
       shopDomain: 'merchant.myshopify.com',
@@ -712,7 +806,7 @@ const CATALOG_SAVED_SLICES_BRANCHES = Object.freeze([
     action,
     mutates: action === 'delete' || action === 'refresh',
     required: ['action', 'sliceId'],
-    forbidden: ['shopDomain', 'label', 'variantIds'],
+    forbidden: ['limit', 'cursor', 'shopDomain', 'label', 'variantIds'],
     example: { action, sliceId: 'csl_saved_01234567' },
   })),
 ]);
@@ -851,7 +945,6 @@ const PRACTICE_RUN_UNTIL_INPUT_SCHEMA = Object.freeze({
         }, ['sku', 'threshold']),
         practiceRunUntilConditionInputSchema('order-recorded'),
         practiceRunUntilConditionInputSchema('return-recorded'),
-        practiceRunUntilConditionInputSchema('return-request-pending'),
         practiceRunUntilConditionInputSchema('incoming-inventory-landed', {
           sku: { type: 'string', minLength: 1, maxLength: 100 },
         }, ['sku']),
@@ -1111,18 +1204,7 @@ function receiptProjection(value) {
   const practiceRun = attempt.practiceRun ?? value?.practiceRun ?? null;
   const calls = Array.isArray(value?.events?.calls) ? value.events.calls : [];
   const actions = Array.isArray(value?.events?.actions) ? value.events.actions : [];
-  const assertions = Array.isArray(value?.receiptEvidence?.effectiveAssertions)
-    ? value.receiptEvidence.effectiveAssertions.slice(0, 50).map((assertion) => ({
-      id: assertion.id,
-      status: assertion.statusLabel,
-      observedStatus: assertion.observedStatus,
-      evaluationSubject: assertion.evaluationSubject,
-      rejectionResponsibleLayers: assertion.rejectionResponsibleLayers ?? [],
-      ownershipStatement: assertion.ownershipStatement ?? null,
-      label: assertion.label,
-      detail: assertion.detail,
-    }))
-    : [];
+  const assertionOutcomes = value?.assertionOutcomes;
   const verdict = value?.report?.verdict && typeof value.report.verdict === 'object'
     ? Object.fromEntries(['status', 'outcome', 'grade', 'score', 'headline', 'horizonDays']
       .filter((key) => value.report.verdict[key] !== undefined)
@@ -1169,8 +1251,21 @@ function receiptProjection(value) {
   const gate = value?.gate ?? value?.report?.gate;
   const rejectionAttribution = value?.rejectionAttribution ?? value?.report?.rejectionAttribution;
   const reportBack = value?.reportBack ?? value?.report?.reportBack;
+  // MEG-1386: selected from the server-compiled Conduct plane the report-back already carries. MCP
+  // resolves nothing here and derives nothing; it selects the one object or publishes its absence.
+  const conductAuthority = Array.isArray(reportBack?.planes)
+    ? reportBack.planes.find((plane) => plane?.plane === 'conduct')?.facts?.authority
+      ?? reportBack.planes.find((plane) => plane?.id === 'conduct')?.facts?.authority
+    : undefined;
   const takeHome = value?.takeHome ?? value?.report?.takeHome;
   const eventResolution = value?.eventResolution ?? value?.report?.eventResolution;
+  // MEG-1364: the declared modeled mechanisms and what this run measured about each one, carried
+  // whole. This projection used to drop the only per-mechanism values in the payload, so a caller's
+  // model was handed a headline about a bundle store with nothing about bundles in it — and no way
+  // to tell a mechanism that measured zero from one that is not modeled. Read from the report's one
+  // mechanism location, which the server fills for graded and ungraded conclusions alike; selecting
+  // members here would be a second authority over the same table.
+  const modeledMechanisms = value?.report?.modeledMechanisms;
   return secretSafe({
     schemaVersion: value?.schemaVersion,
     storeIdentity: value.storeIdentity,
@@ -1183,25 +1278,40 @@ function receiptProjection(value) {
     summary: {
       calls: footprint?.callCount ?? calls.length,
       actions: footprint?.recordedActionCount ?? actions.length,
-      rejectedCalls: calls.filter((call) => call?.rejected === true || Number(call?.status) >= 400).length,
+      // MEG-1386: the server's one compiled Conduct authority, not a second count. This line used
+      // to re-scan the call rows here, so a rejected READ arrived at a caller's model as an
+      // undifferentiated rejected call while the receipt beside it said something else. Absent
+      // authority publishes null rather than a locally reconstructed number.
+      rejectedCalls: conductAuthority ? conductAuthority.rejections.recorded : null,
+      rejectedReads: conductAuthority ? conductAuthority.rejections.rejectedReads : null,
+      blockedWrites: conductAuthority ? conductAuthority.rejections.rejectedMutations : null,
       acceptedWrites: footprint?.acceptedWrites ?? calls.filter((call) => Number(call?.actionCount ?? 0) > 0).length,
       ...(footprint?.unmeasuredActionCount ? { unmeasuredActions: footprint.unmeasuredActionCount } : {}),
     },
+    // The complete compiled object, passed through unchanged: exact rejected-read and blocked-write
+    // counts, explicit recovery links, and the compact named behavior and blocked-attempt rows with
+    // their occurrence counts and recorder call references.
+    conductAuthority: conductAuthority ?? null,
     receipt: {
       summary: value?.receiptEvidence?.summary,
-      assertions,
       ...(value?.receiptEvidence?.expectedRefusals ? { expectedRefusals: value.receiptEvidence.expectedRefusals } : {}),
     },
+    ...(assertionOutcomes && typeof assertionOutcomes === 'object' ? { assertionOutcomes } : {}),
     changes: Array.isArray(value?.changes) ? value.changes : [],
     ...(defaultVerdict && typeof defaultVerdict === 'object' ? { defaultVerdict } : {}),
     ...(resultSemantics && typeof resultSemantics === 'object' ? { resultSemantics } : {}),
     ...(gate && typeof gate === 'object' ? { gate } : {}),
     ...(rejectionAttribution && typeof rejectionAttribution === 'object' ? { rejectionAttribution } : {}),
-    ...(reportBack?.schemaVersion === 'meguro.receipt-report-back.v1' ? { reportBack } : {}),
-    ...(takeHome?.schemaVersion === 'meguro.receipt-take-home.v1' ? { takeHome } : {}),
+    ...(reportBack?.schemaVersion === 'meguro.receipt-report-back.v5' ? { reportBack } : {}),
+    ...(takeHome?.schemaVersion === 'meguro.receipt-take-home.v3' ? { takeHome } : {}),
     ...(eventResolution?.schemaVersion === 'meguro.template-event-resolution.v1' ? { eventResolution } : {}),
+    // Absence is PUBLISHED as null rather than dropped: a silently missing table reads to a model
+    // exactly like a store that models no mechanism, which is the confusion this field exists to end.
+    modeledMechanisms: modeledMechanisms && typeof modeledMechanisms === 'object' ? modeledMechanisms : null,
     ...(verdict ? { verdict } : {}),
     ...(measurement ? { measurement } : {}),
+    ...railBrief(value?.brief),
+    ...(value?.nextStep && typeof value.nextStep === 'object' ? { nextStep: value.nextStep } : {}),
     ...(value?.publicReceipts?.run ? {
       publicReceipt: value.publicReceipts.run,
       deployGate: 'Gate a deploy by fetching publicReceipt.canonicalPath as the complete unauthenticated HTTPS URL and verifying the SHA-256 of its exact response bytes equals publicReceipt.sha256. Repeat the same check for impactPublicReceipt when present.',
@@ -1241,8 +1351,8 @@ function runsListProjection(value, lifecycle) {
     }),
     ...(runs.length === 0 ? {
       emptyState: {
-        message: `No ${lifecycle ?? 'matching'} Shopify dev-store history runs were found. This says nothing about practice simulation attempts.`,
-        practiceAttemptRecovery: 'Call practice_runs_list to discover practice simulation attempts, then pass one exact attemptId to practice_run_report or practice_run_impact.',
+        message: `No ${lifecycle ?? 'matching'} Shopify dev-store history runs were found. This says nothing about practice simulation runs.`,
+        practiceAttemptRecovery: 'Call practice_runs_list to discover practice simulation runs, then pass one exact attemptId to practice_run_report or practice_run_impact.',
       },
     } : {}),
     clockDiscipline: 'runClock names lifecycle timestamps; worldClock names scenario coordinates and does not invent an unreported Store-time.',
@@ -1311,13 +1421,25 @@ function practiceRunsProjection(value, storeId, storeSelection, workspaceId) {
   if (!Number.isSafeInteger(value?.total) || value.total < 0) {
     throw new Error('Meguro practice runs response did not contain a valid total');
   }
+  if (value?.nextCursor !== null && value?.nextCursor !== undefined && typeof value.nextCursor !== 'string') {
+    throw new Error('Meguro practice runs response did not contain a valid nextCursor');
+  }
   return secretSafe({
     schemaVersion: 'meguro.practice-run-list.v1',
     storeId,
     storeSelection,
     total: value.total,
+    nextCursor: value?.nextCursor ?? null,
     attempts: attempts
-      .map((attempt) => ({
+      // MEG-1571: a completed run's item IS the server-owned receipt comparison card, so comparing
+      // N runs is this one call. MCP passes it through and derives no comparison fact of its own.
+      .map((attempt) => (attempt.comparisonCard ? attempt.comparisonCard
+        : typeof attempt.comparisonCardUnavailableReason === 'string' ? {
+          attemptId: attempt.attemptId,
+          code: 'receipt-comparison-card-unavailable',
+          reason: attempt.comparisonCardUnavailableReason,
+        }
+        : {
         attemptId: attempt.attemptId,
         state: typeof attempt.practiceRun?.state === 'string' ? attempt.practiceRun.state : null,
         clock: {
@@ -1332,6 +1454,8 @@ function practiceRunsProjection(value, storeId, storeSelection, workspaceId) {
           attemptId: attempt.attemptId,
           ...(workspaceId ? { workspaceId } : {}),
         },
+        ...railBrief(attempt.brief),
+        ...(attempt.nextStep && typeof attempt.nextStep === 'object' ? { nextStep: attempt.nextStep } : {}),
       })),
   });
 }
@@ -1347,10 +1471,10 @@ function practiceAttemptComparisonGuidanceFor(toolName, a, b) {
       type: 'text',
       text: JSON.stringify({
         code: 'practice-attempt-comparator-unavailable',
-        message: `${toolName} compares history-run identities that are not exposed by hosted MCP. A pa-* id names a practice simulation attempt, and Meguro has no cross-attempt comparator today.`,
+        message: `${toolName} compares history-run identities that are not exposed by hosted MCP. A pa-* id names a practice simulation run, and Meguro has no cross-run comparator today.`,
         attemptIds,
         nextAction: calls.join('; '),
-        stopCondition: `Use the listed practice receipt reads instead. Do not retry ${toolName} with pa-* practice attempt ids.`,
+        stopCondition: `Use the listed practice receipt reads instead. Do not retry ${toolName} with pa-* practice run ids.`,
         workingMethod: {
           calls,
           receiptFacts: 'Read both immutable run receipts and impact receipts. Align like-named impact effectLines by key, preserve each receipt moneyBasis, and subtract the recorded values only after checking the comparison basis below.',
@@ -1375,16 +1499,27 @@ function practiceAttemptHistoryReadGuidance(toolName, attemptId) {
       type: 'text',
       text: JSON.stringify({
         code: 'practice-attempt-not-history-run',
-        message: `${toolName} reads Shopify dev-store history runs created by run_start. ${attemptId} is a practice simulation attempt returned by practice_run_start, not a history run.`,
+        message: `${toolName} reads Shopify dev-store history runs created by run_start. ${attemptId} is a practice simulation run returned by practice_run_start, not a history run.`,
         nextAction: nextCall,
-        stopCondition: `Call ${nextCall} instead. Do not retry ${toolName} with a pa-* practice simulation attempt id.`,
+        stopCondition: `Call ${nextCall} instead. Do not retry ${toolName} with a pa-* practice simulation run id.`,
       }, null, 2),
     }],
     isError: true,
   };
 }
 
-function practiceStoreConnectionNotFoundGuidance(storeId) {
+/**
+ * MEG-1563: the served brief is a declaration, not a bare list.
+ *
+ * A run that cannot state its pinned mission now says so with a reason. Projecting only arrays
+ * dropped that reason silently, which is the unexplained empty brief this ticket removes.
+ */
+function railBrief(value) {
+  if (value && typeof value === 'object' && typeof value.declaration === 'string') return { brief: value };
+  return {};
+}
+
+function practiceStoreConnectionNotFoundGuidance(storeId, nextStep) {
   return {
     content: [{
       type: 'text',
@@ -1393,6 +1528,7 @@ function practiceStoreConnectionNotFoundGuidance(storeId) {
         message: `get_connection_details could not find practice store ${storeId} in this account or the store is no longer active.`,
         nextAction: 'Call stores_list({}) and use an exact current storeId from the returned stores array.',
         stopCondition: `If stores_list({}) returns no current stores, stop: there is no practice store to connect. Do not retry ${JSON.stringify(storeId)}.`,
+        ...(nextStep && typeof nextStep === 'object' ? { nextStep: secretSafe(nextStep) } : {}),
       }, null, 2),
     }],
     isError: true,
@@ -1438,7 +1574,7 @@ function legacyGateArtifactNotFoundGuidance(runId) {
       type: 'text',
       text: JSON.stringify({
         code: 'legacy-gate-artifact-not-found',
-        message: `No retained legacy Configured Receipt Gate artifact exists for ${runId}. It is not a history-run id or pa-* practice simulation attempt id.`,
+        message: `No retained legacy Configured Receipt Gate artifact exists for ${runId}. It is not a history-run id or pa-* practice simulation run id.`,
         nextAction: 'Call gate_verdict({}) to read the latest Configured Receipt Gate verdict.',
         stopCondition: `Do not retry ${JSON.stringify(runId)}. The legacy artifact cannot be created from a customer surface; stop after gate_verdict({}).`,
       }, null, 2),
@@ -1680,6 +1816,7 @@ export function createTools(config) {
   const apiBaseUrl = String(config.apiBaseUrl ?? '').replace(/\/+$/, '');
   const dashboardUrl = String(config.dashboardUrl ?? '').replace(/\/+$/, '');
   const practiceApiToken = String(config.practiceApiToken ?? '').trim();
+  const anonymousTemplateCatalog = config.anonymousTemplateCatalog ?? null;
   const fetchImpl = config.fetchImpl ?? fetch;
   let cachedBuildSha = typeof config.buildSha === 'string' && config.buildSha.trim() ? config.buildSha.trim() : '';
 
@@ -1949,6 +2086,7 @@ export function createTools(config) {
       errors,
       ...(catalogConnection ? { allowedShopDomains } : {}),
       ...(Array.isArray(body.fleet) ? { fleet: body.fleet } : {}),
+      ...(body.nextStep && typeof body.nextStep === 'object' ? { nextStep: body.nextStep } : {}),
       supportCode: await fleetSupportCode(supportRouteForFleetFailure(toolName, path), requestId),
     });
     const result = { content: [{ type: 'text', text: JSON.stringify(stable, null, 2) }], isError: true };
@@ -1987,7 +2125,7 @@ export function createTools(config) {
         httpStatus: response.status,
         error: { message: rawMessage },
         teaching: {
-          meaning: `${requestedId} was not found as a current Shopify dev-store history run in this account. run_resume does not accept a practice simulation attemptId or an invented id.`,
+          meaning: `${requestedId} was not found as a current Shopify dev-store history run in this account. run_resume does not accept a practice simulation run id or an invented id.`,
           nextStep: 'Call runs_list({}), choose an exact runId whose lifecycle is paused or failed, then call run_resume({ runId: "<exact runId>" }).',
           stopCondition: 'If runs_list({}) has no paused or failed history run, stop. Do not retry the missing runId.',
         },
@@ -2110,7 +2248,7 @@ export function createTools(config) {
           } } : {}),
           teaching: {
             meaning: startPairNotFound || preflightPairNotFound
-              ? 'This tenant-safe not-found refusal means the requested practice attempt and connected development-store domain pair is unavailable to this account; Meguro does not reveal which member of the pair was absent.'
+              ? 'This tenant-safe not-found refusal means the requested practice run and connected development-store domain pair is unavailable to this account; Meguro does not reveal which member of the pair was absent.'
               : examIdentityNotFound
                 ? 'No Shopify Exam with this examId is available to this account. Exam identities are created only by exam_start.'
               : source.code === 'exam-ineligible'
@@ -2199,6 +2337,22 @@ export function createTools(config) {
     };
   }
 
+  async function practiceRunConsoleUrlFields(attemptId, workspaceId) {
+    if (typeof attemptId !== 'string' || !PRACTICE_ATTEMPT_ID.test(attemptId)) return consoleUrlFields();
+    try {
+      const response = await practiceApi(
+        'POST',
+        `/practice/playbacks/${encodeURIComponent(attemptId)}/console-reference`,
+        {},
+        { workspaceId },
+      );
+      if (!response.ok) return consoleUrlFields();
+      return consoleUrlFields(response.json?.ref, response.json?.expiresAt);
+    } catch {
+      return consoleUrlFields();
+    }
+  }
+
   const rawDefinitions = [
     {
       name: 'docs_read',
@@ -2228,7 +2382,7 @@ export function createTools(config) {
     },
     {
       name: 'templates_list',
-      description: 'List the complete ordered, public-safe practice-store template catalog available to store_create; it is not filtered by stores already in the fleet. Each row carries only what a cold agent needs to choose — key, label, category, recommended, bestFor and recommendedRunDays. Call template_get({ templateKey }) for one template\'s complete record: supported reads and writes, operation contracts, unsupported contracts, capability boundaries, modeled evidence and physics, and rubric fields. starterRecommendation names every server-recommended template and provides a server-owned starterPlans entry for every selectable template. Each plan states the authenticated account tier, ideal horizon, exact first practice_run_start clock, run-start availability, and continuation. While the one account onboarding grant is available, every template is recommendable and its plan carries that authorization; afterward the same plans apply ordinary tier policy. If no executable recommendation is available, the catalog remains complete and starterRecommendation.recommendationUnavailable explains why. The matching recommended boolean follows the server declaration, and recommendedRunDays remains each template\'s ideal simulation length. The response excludes customer profiles, scenario presets, credentials, and private route payload. An OAuth grant may select an owned non-default workspace; an API key remains bound to its own workspace.',
+      description: 'List the complete ordered, public-safe practice-store template catalog available to store_create; it is not filtered by stores already in the fleet. Each row carries only what a cold agent needs to choose — key, label, category, recommended, bestFor and recommendedRunDays. Call template_get({ templateKey }) for one template\'s complete record: supported reads and writes, operation contracts, unsupported contracts, capability boundaries, modeled evidence and physics, and rubric fields. starterRecommendation names every server-recommended template and provides a server-owned starterPlans entry for every selectable template. Each plan states the authenticated account tier, ideal horizon, exact first practice_run_start clock, run-start availability, and continuation. While the included evaluation is available, every template is recommendable and its plan carries that authorization; afterward the same plans apply ordinary tier policy. If no executable recommendation is available, the catalog remains complete and starterRecommendation.recommendationUnavailable explains why. The matching recommended boolean follows the server declaration, and recommendedRunDays remains each template\'s ideal simulation length. The response excludes customer profiles, scenario presets, credentials, and private route payload. An OAuth grant may select an owned non-default workspace; an API key remains bound to its own workspace.',
       inputSchema: {
         type: 'object',
         additionalProperties: false,
@@ -2290,7 +2444,7 @@ export function createTools(config) {
     },
     {
       name: 'store_passport',
-      description: 'Read a machine-shaped Store Passport in the selected workspace: template identity, exact history span, Store time, catalog and inventory counts, commerce totals, demand profile, run summary, and disposal consequences. OAuth may select an owned workspace; an API key remains workspace-bound.',
+      description: 'Read a machine-shaped Store Passport in the selected workspace: template identity, exact history span, Store time, catalog and inventory counts, commerce totals, demand profile, the effective modeled supplier lead time in Store days at generation.replenishment.leadTimeDays, run summary, and disposal consequences. OAuth may select an owned workspace; an API key remains workspace-bound.',
       inputSchema: {
         type: 'object', additionalProperties: false,
         properties: {
@@ -2300,10 +2454,26 @@ export function createTools(config) {
         required: ['storeId'],
       },
     },
+    {
+      name: 'sample_store_reset',
+      description: 'Repair the one sample practice store this account already owns and return it ready to use under the same store id. This account-scoped call takes no arguments: the account\'s single sample claim names the target, so it can never create a second sample store, a second store id, or a second included evaluation. A sample store that is already usable is returned unchanged with reset:false; a sample store that is archived or has lost its simulation state is repaired and returned with reset:true. Its onboardingEvaluation field reports whether an in-progress or already-consumed evaluation was preserved, or whether a half-written evaluation was cleared and the included evaluation made available again. An account that owns no sample practice store gets a typed teaching error and nothing is created.',
+      inputSchema: {
+        type: 'object', additionalProperties: false,
+        properties: {},
+        required: [],
+      },
+    },
     {
       name: 'workspaces_list',
-      description: 'List every workspace owned by the token account plus the authoritative MEG-592 capacity projection. The OAuth grant is account-bound, so this account-scoped tool needs no workspace selector and does not re-derive tier limits.',
-      inputSchema: { type: 'object', additionalProperties: false, properties: {}, required: [] },
+      description: 'List a deterministic page of workspaces owned by the token account plus the authoritative MEG-592 capacity projection. The response carries full-account total and an opaque nextCursor; pass that cursor unchanged to recover the next page. The OAuth grant is account-bound, so this account-scoped tool needs no workspace selector and does not re-derive tier limits.',
+      inputSchema: {
+        type: 'object', additionalProperties: false,
+        properties: {
+          limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Maximum workspace rows in this page. Defaults to 100.' },
+          cursor: { type: 'string', minLength: 1, description: 'Opaque nextCursor returned by the preceding workspaces_list page. Omit to start at the first page.' },
+        },
+        required: [],
+      },
     },
     {
       name: 'workspace_create',
@@ -2359,7 +2529,7 @@ export function createTools(config) {
     },
     {
       name: 'catalog_slices_saved',
-      description: 'Manage the existing saved-catalog-slice lifecycle with action=list, get, save, delete, refresh, or changes. save/refresh read the connected Shopify store; delete removes only the exact saved slice; list/get/changes are Meguro reads. The worst-case annotation is intentionally destructive and outward because this grouped tool includes delete and external refresh.',
+      description: 'Manage the existing saved-catalog-slice lifecycle with action=list, get, save, delete, refresh, or changes. list accepts limit and opaque cursor, and returns the server-owned full total plus nextCursor. save/refresh read the connected Shopify store; delete removes only the exact saved slice; list/get/changes are Meguro reads. The worst-case annotation is intentionally destructive and outward because this grouped tool includes delete and external refresh.',
       inputSchema: CATALOG_SAVED_SLICES_INPUT_SCHEMA,
     },
     {
@@ -2466,7 +2636,7 @@ export function createTools(config) {
     },
     {
       name: 'runs_diff',
-      description: 'Legacy receipt comparison for two Shopify dev-store history runs created by run_start. It does not compare practice simulation attempts returned by practice_run_start; a pa-* id receives a teaching error with the terminating receipt-fact method. For history runs it verifies the shared prefix, finds the fork, and returns impact receipt deltas. Prefer twin_diff for the named history-run impact receipt vocabulary. "Not comparable" is an honest answer, not an error in your usage. Receipt availability and expiry guidance are server-owned and returned by the receipt response.',
+      description: 'Legacy receipt comparison for two Shopify dev-store history runs created by run_start. It does not compare practice simulation runs returned by practice_run_start; a pa-* id receives a teaching error with the terminating receipt-fact method. For history runs it verifies the shared prefix, finds the fork, and returns impact receipt deltas. Prefer twin_diff for the named history-run impact receipt vocabulary. "Not comparable" is an honest answer, not an error in your usage. Receipt availability and expiry guidance are server-owned and returned by the receipt response.',
       inputSchema: {
         type: 'object',
         additionalProperties: false,
@@ -2519,7 +2689,7 @@ export function createTools(config) {
     },
     {
       name: 'runs_list',
-      description: 'Discover the owned Shopify dev-store history runs readable through hosted OAuth. A completed server-owned twin relation is projected as twinPair with pairId, baseline/treated role, and exact counterpartRunId; pass those returned identities to run_status, run_report, and twin_diff. It does not list practice simulation attempts returned by practice_run_start. Optional lifecycle filtering supports running, paused, completed, failed, or cleaning.',
+      description: 'Discover the owned Shopify dev-store history runs readable through hosted OAuth. A completed server-owned twin relation is projected as twinPair with pairId, baseline/treated role, and exact counterpartRunId; pass those returned identities to run_status, run_report, and twin_diff. It does not list practice simulation runs returned by practice_run_start. Optional lifecycle filtering supports running, paused, completed, failed, or cleaning.',
       inputSchema: {
         type: 'object',
         additionalProperties: false,
@@ -2559,7 +2729,7 @@ export function createTools(config) {
     },
     {
       name: 'exam_preflight',
-      description: 'Read-only Shopify Exam readiness for one immutable completed practice attempt and one exact connected Shopify development-store domain. Creates no Exam row and makes zero Shopify mutations. An ineligible result teaches the exact captured-evidence recovery; transient evidence reads remain undetermined and retryable rather than becoming negative evidence.',
+      description: 'Read-only Shopify Exam readiness for one immutable completed practice run and one exact connected Shopify development-store domain. Creates no Exam row and makes zero Shopify mutations. An ineligible result teaches the exact captured-evidence recovery; transient evidence reads remain undetermined and retryable rather than becoming negative evidence.',
       inputSchema: {
         type: 'object', additionalProperties: false,
         properties: {
@@ -2571,7 +2741,7 @@ export function createTools(config) {
     },
     {
       name: 'exam_start',
-      description: 'Start or safely continue a Shopify Exam from one immutable practice attempt on the exact typed development-store domain. The tool performs idempotent create/preview/typed-confirm setup, then advances at most one bounded execution or cleanup checkpoint. Call exam_status after every invocation; while nextAction names exam_start, repeat the same arguments. GET polling never advances or cleans the Exam and ambiguous delivery is never retried blindly.',
+      description: 'Start or safely continue a Shopify Exam from one immutable practice run on the exact typed development-store domain. The tool performs idempotent create/preview/typed-confirm setup, then advances at most one bounded execution or cleanup checkpoint. Call exam_status after every invocation; while nextAction names exam_start, repeat the same arguments. GET polling never advances or cleans the Exam and ambiguous delivery is never retried blindly.',
       inputSchema: {
         type: 'object', additionalProperties: false,
         properties: {
@@ -2601,14 +2771,14 @@ export function createTools(config) {
     },
     {
       name: 'practice_run_start',
-      description: 'Start an external-agent practice simulation run on an existing Meguro practice store, or continue one completed segment on the same aging store when server authorization allows it. The returned lifecycleContract explains that accepted writes are disposable attempt-local state, actions remain in receipt and Impact evidence, the store returns to baseline after completion, terminal reads remain available while writes are refused, and ordinary completed runs meter once. A fresh account\'s first accepted start may bind its one account-owned onboarding evaluation grant to the chosen store/template/root and pinned ideal horizon; every authorized segment is unmetered, while every run after that horizon follows ordinary tier policy. A fresh start replays the practice store\'s original scenario baseline as segment 1 by default; chaining is explicit through continueFromAttemptId. An optional immutable assertionPlan may predeclare exact expected negative-control refusals before call sequence zero; only exact server-matched reason, layer, target or request, and cardinality can prevent that rejection from becoming an unhandled Configured Receipt Gate failure. When clock.simulationDays is omitted, Meguro derives the full remaining scenario arc. Without active onboarding authorization, Builder plans a capped legal segment while Free or Solo refuses an above-cap arc. For an executable onboarding call, choose the matching starterRecommendation.starterPlans entry returned by templates_list and use its exact practiceRunStart.clock; otherwise use the returned ordinary starterPlan. Every accepted start returns a machine-readable segmentPlan with the exact Store-day range, authorization, and continuation narration. An advance target that reaches or crosses the planned end requires explicit terminal confirmation before the run ends; state-changing Admin calls require a running run, so use return-request-pending to stop on an actionable return before the planned end. The returned machine-readable simulationRunClock announces every exit: 1 hour for an agent that never executes, 48 hours with neither agent contact nor Store-time advance, and a 7-day run age (2 days on Free). Takes the canonical practice-store id (`storeId`) exactly as returned by get_connection_details, and returns the run identity (`attemptId`) every later practice_run_* tool uses — the store id and the run id are different identifiers. Meguro Console is quick proof, while the agency agent still runs in the caller\'s own environment. Returns the same server-authoritative practice-run contract without connection credentials.',
+      description: 'Start an external-agent practice simulation run on an existing Meguro practice store, or continue one completed prior run on the same aging store when server authorization allows it. The returned lifecycleContract explains that accepted writes are disposable run-local state, actions remain in receipt and Impact evidence, the store returns to baseline after completion, terminal reads remain available while writes are refused, and ordinary completed runs meter once. Your account includes one evaluation on the practice store you choose. The first accepted run reserves it for that store and its planned Store-day horizon. Runs inside that horizon don\'t use monthly simulation runs; after it, plan limits apply. A fresh run replays the practice store\'s original scenario baseline as run 1 by default; continued runs are explicit through continueFromAttemptId. An optional immutable assertionPlan may predeclare exact expected negative-control refusals before call sequence zero; only exact server-matched reason, layer, target or request, and cardinality can prevent that rejection from becoming an unhandled Configured Receipt Gate failure. When clock.simulationDays is omitted, Meguro derives the full remaining scenario arc. Without active included-evaluation authorization, Builder plans a capped legal run while Free or Solo refuses an above-limit arc. For an executable included-evaluation call, choose the matching starterRecommendation.starterPlans entry returned by templates_list and use its exact practiceRunStart.clock; otherwise use the returned ordinary starterPlan. Every accepted start returns a machine-readable segmentPlan with the exact Store-day range, authorization, and run-plan narration. An advance target that reaches or crosses the planned end requires explicit terminal confirmation before the run ends; state-changing Admin calls require a running run. The returned machine-readable simulationRunClock announces every exit: 1 hour for an agent that never executes, 48 hours with neither agent contact nor Store-time advance, and a 7-day run age (2 days on Free). Takes the canonical practice-store id (`storeId`) exactly as returned by get_connection_details, and returns the run identity (`attemptId`) every later practice_run_* tool uses — the store id and the run id are different identifiers. Meguro Console is quick proof, while the agency agent still runs in the caller\'s own environment. Returns the same server-authoritative practice-run contract without connection credentials.',
       inputSchema: {
         type: 'object',
         additionalProperties: false,
         properties: {
           workspaceId: OPTIONAL_WORKSPACE_SELECTOR_INPUT_SCHEMA,
           storeId: { ...PRACTICE_STORE_ID_INPUT_SCHEMA, description: 'Canonical Meguro practice-store id (tenant-owned), as returned by get_connection_details.' },
-          continueFromAttemptId: { type: 'string', minLength: 4, maxLength: 128, pattern: '^pa-[a-z0-9][a-z0-9-]{0,124}$', description: 'Completed prior segment to continue on the same aging practice store. Available only when the server tier policy allows continuation. On Builder, omit clock.simulationDays to let Meguro plan the next legal segment automatically.' },
+          continueFromAttemptId: { type: 'string', minLength: 4, maxLength: 128, pattern: '^pa-[a-z0-9][a-z0-9-]{0,124}$', description: 'Completed prior run to continue on the same aging practice store. Available only when the server tier policy allows continuation. On Builder, omit clock.simulationDays to let Meguro plan the next legal run automatically.' },
           clock: {
             type: 'object',
             additionalProperties: false,
@@ -2669,7 +2839,7 @@ export function createTools(config) {
     },
     {
       name: 'practice_runs_list',
-      description: 'List bounded practice simulation attempt facts for one exact practice store: attemptId, lifecycle state, Store-clock summary, and a receiptRef that can be passed unchanged to practice_run_report. Store selection follows one fail-closed ladder: receiptId derives its owning store; otherwise an explicit storeId wins; omission is allowed only when the workspace has exactly one current store; zero or multiple stores return a structured store-selection-required error and never choose silently. An OAuth grant may select an owned workspace; an account API key remains bound to its own workspace.',
+      description: 'List recoverable pages of practice simulation runs for one exact practice store. A completed comparable row is `meguro.receipt-comparison-card.v1`: use `identities.attemptId`, with this call\'s workspace context, in practice_run_report or practice_run_impact; it contains `counts`, `dimensions`, `gate`, `links`, `sourceReceipt`, and `evidenceBoundary`, and has no `receiptRef`. A non-completed row instead has `attemptId`, lifecycle `state`, `clock`, `receiptRef`, `brief`, and `nextStep`; a completed run without a comparable card has `attemptId`, `code: "receipt-comparison-card-unavailable"`, and `reason`. `total` is the complete authorized store-filtered count; copy `nextCursor` unchanged into the next call until it is null. Store selection follows one fail-closed ladder: receiptId derives its owning store; otherwise an explicit storeId wins; omission is allowed only when the workspace has exactly one current store; zero or multiple stores return a structured store-selection-required error and never choose silently. An OAuth grant may select an owned workspace; an account API key remains bound to its own workspace.',
       inputSchema: {
         type: 'object',
         additionalProperties: false,
@@ -2677,13 +2847,15 @@ export function createTools(config) {
           workspaceId: { type: 'string', minLength: 1, description: 'Optional OAuth selector for an account-owned non-default workspace. An account API key can name only its bound workspace.' },
           storeId: { ...PRACTICE_STORE_ID_INPUT_SCHEMA, description: 'Optional exact practice-store id from stores_list. Omit only with receiptId or when the workspace has exactly one current store.' },
           receiptId: { type: 'string', minLength: 4, maxLength: 128, pattern: '^pa-[a-z0-9][a-z0-9-]{0,124}$', description: 'Optional known pa-* practice receipt identity. Meguro derives its owning store and refuses a conflicting storeId.' },
+          limit: { type: 'integer', minimum: 1, maximum: 100, description: 'Optional page size. Defaults to 100; never request more than 100.' },
+          cursor: { type: 'string', minLength: 1, maxLength: 1024, description: 'Optional opaque nextCursor returned by the preceding practice_runs_list page. Copy unchanged with the same store selection.' },
         },
         required: [],
       },
     },
     {
       name: 'practice_run_status',
-      description: 'Read the server-authoritative state of an external-agent practice simulation run, including its announced simulation-run deadlines, immutable simulation run receipt after any exit, and lifecycleContract. That contract explains that accepted writes are disposable attempt-local state, actions remain in receipt and Impact evidence, the store returns to baseline after completion, terminal reads remain available while writes are refused, and an ordinary completed run is metered once while the explicitly provisioned sample is exempt. Immediately before advancing, copy practiceRun.advanceCursor unchanged into practice_run_advance; do not choose between currentDay and watermarkDay or assemble call-sequence fields. If the next target reaches or crosses endDay, follow the exact terminal-confirmation retry returned by practice_run_advance. A running run authorizes state-changing Admin calls; after completion later writes receive the stable run-complete refusal. Use Console for quick proof; the tested agent remains in the caller\'s environment.',
+      description: 'Read the server-authoritative state of an external-agent practice simulation run, including its announced simulation-run deadlines, immutable simulation run receipt after any exit, and lifecycleContract. That contract explains that accepted writes are disposable run-local state, actions remain in receipt and Impact evidence, the store returns to baseline after completion, terminal reads remain available while writes are refused, and an ordinary completed run is metered once while the explicitly provisioned sample is exempt. Immediately before advancing, copy practiceRun.advanceCursor unchanged into practice_run_advance; do not choose between currentDay and watermarkDay or assemble call-sequence fields. If the next target reaches or crosses endDay, follow the exact terminal-confirmation retry returned by practice_run_advance. A running run authorizes state-changing Admin calls; after completion later writes receive the stable run-complete refusal. Use Console for quick proof; the tested agent remains in the caller\'s environment.',
       inputSchema: {
         type: 'object', additionalProperties: false,
         properties: {
@@ -2707,7 +2879,7 @@ export function createTools(config) {
     },
     {
       name: 'practice_run_advance',
-      description: 'Advance an external-agent practice run by whole days or until one closed-set commerce condition, using the server-owned optimistic-concurrency advanceCursor. Accepted writes are disposable attempt-local state: they remain in receipt and Impact evidence, while the underlying practice store returns to baseline after completion. Terminal reads remain available and terminal writes are refused. An advance that reaches or crosses planned endDay refuses without changing Store time unless the caller explicitly retries the returned shape with confirmConclusion: true; that confirmed retry concludes the attempt and closes its write lane. return-request-pending stops before planned end with the evaluated Store day, pending-request count, and one bounded opportunity for the next read; it never resolves the request automatically. If no opportunity exists before planned end, the explicit confirmation path ends in the stable run-complete refusal for later writes and offers no write suggestion. State-changing Admin calls require a running run. Immediately before every advance, call practice_run_status and copy practiceRun.advanceCursor unchanged. If it is stale, Meguro refuses without moving Store time and returns a fresh advanceCursor for one exact retry; do not infer from currentDay, watermarkDay, or call-sequence fields. Before durable agentExecutionStartedAt exists, at most 7 Store days may be advanced; connect your agent — any call unlocks further time. Console is quick proof; agent execution remains in the caller\'s environment.',
+      description: 'Advance an external-agent practice run by whole days or until one closed-set commerce condition, using the server-owned optimistic-concurrency advanceCursor. Accepted writes are disposable run-local state: they remain in receipt and Impact evidence, while the underlying practice store returns to baseline after completion. Terminal reads remain available and terminal writes are refused. An advance that reaches or crosses planned endDay refuses without changing Store time unless the caller explicitly retries the returned shape with confirmConclusion: true; that confirmed retry concludes the run and closes its write lane. If an advance reaches the planned end, the explicit confirmation path ends in the stable run-complete refusal for later writes. State-changing Admin calls require a running run. Immediately before every advance, call practice_run_status and copy practiceRun.advanceCursor unchanged. If it is stale, Meguro refuses without moving Store time and returns a fresh advanceCursor for one exact retry; do not infer from currentDay, watermarkDay, or call-sequence fields. Before durable agentExecutionStartedAt exists, at most 7 Store days may be advanced; connect your agent — any call unlocks further time. Console is quick proof; agent execution remains in the caller\'s environment.',
       inputSchema: {
         type: 'object',
         additionalProperties: false,
@@ -2717,7 +2889,7 @@ export function createTools(config) {
           days: { type: 'integer', minimum: 1, description: 'Whole simulated days to advance.' },
           until: PRACTICE_RUN_UNTIL_INPUT_SCHEMA,
           advanceCursor: PRACTICE_RUN_ADVANCE_CURSOR_INPUT_SCHEMA,
-          confirmConclusion: { type: 'boolean', description: 'Set true only after reading the terminal-boundary teaching refusal and choosing to conclude the attempt and close its write lane.' },
+          confirmConclusion: { type: 'boolean', description: 'Set true only after reading the terminal-boundary teaching refusal and choosing to conclude the run and close its write lane.' },
         },
         required: ['attemptId', 'advanceCursor'],
         oneOf: [
@@ -2728,14 +2900,14 @@ export function createTools(config) {
     },
     {
       name: 'practice_run_finish',
-      description: 'End an external-agent practice segment without inventing time or evidence. A segment at planned end completes; an under-measured segment stops and remains explicitly incomplete. For a stopped onboarding segment, the server-owned practiceRun.recovery object gives the exact practice_run_start call that resumes the same bound root at its authoritative watermark. To abandon that incomplete onboarding evaluation permanently, set both permanentStop and acknowledgeIncompleteOnboardingEvaluation true; Meguro preserves evidence and consumed onboarding value. The response includes the immutable segment receipt and announced deadlines. Console is quick proof; agent execution remains in the caller\'s environment.',
+      description: 'End an external-agent practice run without inventing time or evidence. A run at its planned end completes; an under-measured run stops and remains explicitly incomplete. For a stopped included-evaluation run, the server-owned practiceRun.recovery object gives the exact practice_run_start call that resumes the same first included evaluation at its authoritative watermark. To abandon that incomplete included evaluation permanently, set both permanentStop and acknowledgeIncompleteOnboardingEvaluation true; Meguro preserves evidence and consumed included-evaluation value. The response includes the immutable run receipt and announced deadlines. Console is quick proof; agent execution remains in the caller\'s environment.',
       inputSchema: {
         type: 'object', additionalProperties: false,
         properties: {
           workspaceId: OPTIONAL_WORKSPACE_SELECTOR_INPUT_SCHEMA,
           attemptId: { type: 'string', minLength: 4, maxLength: 128, pattern: '^pa-[a-z0-9][a-z0-9-]{0,124}$', description: 'Run identity returned by practice_run_start — not the practice-store id (storeId).' },
-          permanentStop: { type: 'boolean', description: 'Set true only to abandon an under-measured onboarding evaluation permanently. Requires acknowledgeIncompleteOnboardingEvaluation=true.' },
-          acknowledgeIncompleteOnboardingEvaluation: { type: 'boolean', description: 'Set true with permanentStop to acknowledge that the bound onboarding evaluation will remain incomplete while its evidence and consumed value remain preserved.' },
+          permanentStop: { type: 'boolean', description: 'Set true only to abandon an under-measured included evaluation permanently. Requires acknowledgeIncompleteOnboardingEvaluation=true.' },
+          acknowledgeIncompleteOnboardingEvaluation: { type: 'boolean', description: 'Set true with permanentStop to acknowledge that the included evaluation will remain incomplete while its evidence and consumed value remain preserved.' },
         },
         required: ['attemptId'],
         dependentRequired: {
@@ -2746,24 +2918,26 @@ export function createTools(config) {
     },
     {
       name: 'practice_run_report',
-      description: 'Read the run\'s receipt — a bounded receipt summary for a completed external-agent practice run. `reportBack` is the exact server-owned customer summary in the fixed order Mechanics, Conduct, Scenario outcome; MCP passes it through without re-deriving or reclassifying any plane, and modeled money closes its narrative. `takeHome` is the frozen take-home packet the issued receipt itself carries — the same ordered Mechanics, Conduct, Scenario outcome facts the public receipt view serves, plus the source URL and SHA-256, the claims/evidence boundary, the verification steps, and a copy-ready `memo`; MCP passes it through unchanged and compiles no part of it. `eventResolution` passes through the exact creation-pinned template identity/revision, evaluation horizon, measured horizon, and typed event-window result; it never recovers current catalog metadata for a historical run. `gate` is the exact server-owned final machine projection; `rejectionAttribution.gateStatus` is mechanically aligned with it, and neither value is re-derived by MCP. Immutable expected-refusal declarations appear with their exact server-emitted matched or failure status; a matched rejection remains in raw receipt counts while only its unhandled Configured Receipt Gate consequence changes. Interpret `resultSemantics.lifecycle`, `evidenceAssertions`, `technicalPolicyVerdict`, and `modeledScenarioOutcome` as independent named dimensions; there is no implicit overall status. Existing `summary`, `defaultVerdict`, `verdict`, and `measurement` fields are legacy compatibility fields. `report` is the protocol/route compatibility name for the receipt (the tool name and the `operation: "report"` field keep it for wire stability); user-facing language is "receipt". The payload includes an unguessable public receipt id, a complete environment-qualified HTTPS URL in `canonicalPath`, and SHA-256: fetch that URL without credentials and verify the exact bytes before promotion. Raw private request and response payloads stay out of MCP; use Console for quick proof while the agent remains in the caller\'s environment. Receipt availability and expiry guidance are server-owned and returned by the receipt response.',
+      description: 'Read a completed practice run\'s receipt. Omit `detail` (or pass `"card"`) for `meguro.receipt-comparison-card.v1`: `identities`, `counts`, `dimensions`, `gate`, `links`, `sourceReceipt`, and `evidenceBoundary`. Take `identities.attemptId` from a completed practice_runs_list card and preserve that list call\'s workspaceId here; do not invent a completed-row `receiptRef`. `links.publicReceipt` and `links.impactReceipt` are the artifact paths; their corresponding receipt digests are `sourceReceipt.runReceiptDigest` and `sourceReceipt.impactDigest` (each can name an unavailable reason). Respect the card\'s `evidenceBoundary`. Pass `detail: "full"` for the full receipt document: `reportBack`, `takeHome`, and `resultSemantics` are full-detail fields; `reportBack` is the server-owned Mechanics, Conduct, Scenario outcome summary. The public receipt URL is `publicReceipt.canonicalPath` (with `publicReceipt.sha256`), not a top-level `canonicalPath`. Raw private request and response payloads stay out of MCP; receipt availability and expiry guidance are server-owned.',
       inputSchema: {
         type: 'object', additionalProperties: false,
         properties: {
           attemptId: { type: 'string', minLength: 4, maxLength: 128, pattern: '^pa-[a-z0-9][a-z0-9-]{0,124}$', description: 'Run identity returned by practice_run_start — not the practice-store id (storeId).' },
           workspaceId: { type: 'string', minLength: 1, description: 'Optional account-owned workspace coordinate returned by practice_runs_list. Omit for Default.' },
+          detail: { type: 'string', enum: ['card', 'full'], description: "Optional reply detail. Omit or pass 'card' for the bounded receipt comparison card; pass 'full' for the complete receipt document." },
         },
         required: ['attemptId'],
       },
     },
     {
       name: 'practice_run_impact',
-      description: 'Read the impact receipt for a completed external-agent practice run: the base year — the same store, same days, without your agent — compared with your agent\'s year, showing what changed because of your agent (orders, units, and revenue), a footprint of every write, and an integrity gate that reports a reason instead of numbers when the comparison is not clean. `eventResolution` is the exact creation-pinned template identity/revision, evaluation horizon, measured horizon, and typed event-window result; historical runs without that snapshot are explicitly unavailable and never consult current template metadata. The payload includes an unguessable public receipt id, a complete environment-qualified HTTPS URL in `canonicalPath`, and SHA-256: fetch that URL without credentials and verify the exact bytes before promotion. Read-only; never mutates the run and returns no credentials. Takes the run\'s attemptId (from practice_run_start), not the practice-store id (storeId). Receipt availability and expiry guidance are server-owned and returned by the receipt response.',
+      description: 'Read a completed practice run\'s Impact receipt. Omit `detail` (or pass `"card"`) for the same bounded `meguro.receipt-comparison-card.v1` served by practice_run_report: `identities`, `counts`, `dimensions`, `gate`, `links`, `sourceReceipt`, and `evidenceBoundary`. Start with `identities.attemptId` from a completed practice_runs_list card and preserve that list call\'s workspaceId; completed cards have no `receiptRef`. `links.publicReceipt` and `links.impactReceipt` name the artifacts, while `sourceReceipt.runReceiptDigest` and `sourceReceipt.impactDigest` name their corresponding digests (or unavailable reasons). Pass `detail: "full"` for the full Impact document, whose public artifact is `publicReceipt.canonicalPath` with `publicReceipt.sha256`; it is not a top-level `canonicalPath`. Read-only; never mutates the run and returns no credentials. Receipt availability and expiry guidance are server-owned.',
       inputSchema: {
         type: 'object', additionalProperties: false,
         properties: {
           attemptId: { type: 'string', minLength: 4, maxLength: 128, pattern: '^pa-[a-z0-9][a-z0-9-]{0,124}$', description: 'Run identity returned by practice_run_start — not the practice-store id (storeId).' },
           workspaceId: { type: 'string', minLength: 1, description: 'Optional account-owned workspace coordinate returned by practice_runs_list. Omit for Default.' },
+          detail: { type: 'string', enum: ['card', 'full'], description: "Optional reply detail. Omit or pass 'card' for the bounded receipt comparison card; pass 'full' for the complete receipt document." },
         },
         required: ['attemptId'],
       },
@@ -2801,13 +2975,14 @@ export function createTools(config) {
     },
     {
       name: 'admin_schema',
-      description: `Look up an exact, bounded slice of the Shopify Admin GraphQL surface Meguro models for supported versions ${ADMIN_API_SUPPORTED_VERSION_LABEL}; the default is ${ADMIN_API_DEFAULT_VERSION}. Returns a type and its direct fields, a Type.field or root mutation with its arguments and return type, a shared commerce recipe, or an authored valid-not-modeled teaching boundary. A recipe match carries its bindingPlan, and every published mutation recipe carries match.recipe.evidencePlan: the eligibility read to run first (its exact query, variables, a selection sentence naming which returned row to use, and bindings from each response path to the mutation variable it fills), then the mutation, then the existing independent readback. mutation.documentOperationName is the GraphQL document label; mutation.rootField is the Shopify mutation coordinate. Where the mutation has a read-before-write cursor the plan also carries expectedRefusalOperationName — the exact root-field matcher key — plus staleCursorExpectedRefusal reason and layer facts to copy unchanged into an assertionPlan. Mutation example values that only the eligibility read can supply appear as <from-eligibility:VARIABLE_PATH> placeholders, never as plausible literals. Deterministic — it never returns the full schema, tenant data, catalog, or credentials, and on a miss it suggests only exact prefix/substring alternatives. Alternatively, submit query instead of lookup + name — with optional variables, operationName, and apiVersion — to ask what this exact Admin document would receive before you create a practice store or spend credit. It parses the document and classifies the selected operation and every supplied coordinate through the same served schema, versioned compatibility registry, and required-argument recovery authority the served Admin surface uses, returning exactly one state: "served" — no compatibility teaching refusal would be produced; "unsupported-with-recovery" — the exact refusal plus the registry remedy naming the supported coordinate or the exact admin_schema call that answers a required-argument refusal; "out-of-plane" — outside the claimed Admin plane, or no exact recovery authority exists. A compatibility withdrawal also carries teachingRefusal: the same refusal the served Admin surface returns, with its code, coordinate, reason, and next step. A document that will not parse, or whose operation cannot be selected without guessing, comes back with that as its own reason rather than guessed compatibility. Store-free and pre-credit: it creates or reads no practice store, run, attempt, ledger, probe, or checkpoint, consumes no credit, and never executes the submitted document. The two modes are exclusive: pass lookup + name or query, never both.`,
+      description: `Look up an exact, bounded slice of the Shopify Admin GraphQL surface Meguro models for supported versions ${ADMIN_API_SUPPORTED_VERSION_LABEL}; the default is ${ADMIN_API_DEFAULT_VERSION}. Returns a type and its direct fields, a Type.field or root mutation with its arguments and return type, a shared commerce recipe, or an authored valid-not-modeled teaching boundary. A recipe match carries its bindingPlan, and every published mutation recipe carries match.recipe.evidencePlan: the eligibility read to run first (its exact query, variables, a selection sentence naming which returned row to use, and bindings from each response path to the mutation variable it fills), then the mutation, then the existing independent readback. mutation.documentOperationName is the GraphQL document label; mutation.rootField is the Shopify mutation coordinate. Where the mutation has a read-before-write cursor the plan also carries expectedRefusalOperationName — the exact root-field matcher key — plus staleCursorExpectedRefusal reason and layer facts to copy unchanged into an assertionPlan. Mutation example values that only the eligibility read can supply appear as <from-eligibility:VARIABLE_PATH> placeholders, never as plausible literals. Deterministic — it never returns the full schema, tenant data, catalog, or credentials, and on a miss it suggests only exact prefix/substring alternatives. Give an exact current storeId only to replace a static schema-stage next step with that Store's current run-guide step; it returns no connection material. Alternatively, submit query instead of lookup + name — with optional variables, operationName, and apiVersion — to ask what this exact Admin document would receive before you create a practice store or spend credit. It parses the document and classifies the selected operation and every supplied coordinate through the same served schema, versioned compatibility registry, and required-argument recovery authority the served Admin surface uses, returning exactly one state: "served" — no compatibility teaching refusal would be produced; "unsupported-with-recovery" — the exact refusal plus the registry remedy naming the supported coordinate or the exact admin_schema call that answers a required-argument refusal; "out-of-plane" — outside the claimed Admin plane, or no exact recovery authority exists. A compatibility withdrawal also carries teachingRefusal: the same refusal the served Admin surface returns, with its code, coordinate, reason, and next step. A document that will not parse, or whose operation cannot be selected without guessing, comes back with that as its own reason rather than guessed compatibility. The two modes are exclusive: pass lookup + name or query, never both.`,
       inputSchema: {
         type: 'object',
         additionalProperties: false,
         properties: {
           lookup: { type: 'string', enum: ['type', 'field', 'mutation', 'recipe'], description: 'Lookup mode: what to look up — a type, a Type.field, a root mutation, or a commerce recipe. Requires name.' },
           name: { type: 'string', minLength: 1, maxLength: 200, description: 'Lookup mode: exact name, e.g. ProductVariant, ProductVariant.inventoryQuantity, inventoryAdjustQuantities, or a recipe id/operationName like low-inventory or LowInventory.' },
+          storeId: { ...PRACTICE_STORE_ID_INPUT_SCHEMA, description: 'Optional exact current Store id. On lookup mode only, returns that Store run\'s current next step rather than a static schema-stage call.' },
           query: { type: 'string', minLength: 1, maxLength: 30000, description: 'Refusal mode: the exact Admin GraphQL document you intend to send. Classified, never executed.' },
           variables: { type: 'object', description: 'Refusal mode: optional GraphQL variables object (max 20,000 serialized characters). Supplied input-object fields are classified, not executed.' },
           operationName: { type: 'string', minLength: 1, maxLength: 200, description: 'Refusal mode: which operation to classify when the document defines more than one. Without it, a multi-operation document is refused rather than guessed.' },
@@ -2816,7 +2991,7 @@ export function createTools(config) {
         required: [],
         oneOf: [
           { type: 'object', required: ['lookup', 'name'], not: { anyOf: [{ required: ['query'] }, { required: ['variables'] }, { required: ['operationName'] }] } },
-          { type: 'object', required: ['query'], not: { anyOf: [{ required: ['lookup'] }, { required: ['name'] }] } },
+          { type: 'object', required: ['query'], not: { anyOf: [{ required: ['lookup'] }, { required: ['name'] }, { required: ['storeId'] }] } },
         ],
       },
     },
@@ -2886,7 +3061,10 @@ export function createTools(config) {
       const error = schemaValidationError(definition.inputSchema, args);
       if (error) {
         const correction = conditionalToolCorrection(name, args);
-        throw new Error(`${name} arguments do not match the declared input schema: ${error}${correction ? `. Corrected call: ${correction}` : ''}`);
+        const message = name === 'practice_run_advance' && args.advanceCursor === undefined
+          ? 'practice_run_advance arguments require advanceCursor. Call practice_run_status immediately before advancing, then copy practiceRun.advanceCursor unchanged.'
+          : `${name} arguments do not match the declared input schema: ${error}${correction ? `. Corrected call: ${correction}` : ''}`;
+        throw new Error(message);
       }
       return;
     }
@@ -2918,6 +3096,9 @@ export function createTools(config) {
         }
         case 'templates_list': {
           const workspaceId = optionalWorkspaceId(args);
+          if (anonymousTemplateCatalog) {
+            return textResult(JSON.stringify(anonymousStoreTemplatesProjection(anonymousTemplateCatalog)));
+          }
           const response = await fleetRequest(name, 'GET', '/practice/profiles', undefined, { workspaceId });
           return 'error' in response
             ? response.error
@@ -2926,6 +3107,14 @@ export function createTools(config) {
         case 'template_get': {
           const workspaceId = optionalWorkspaceId(args);
           const templateKey = requiredString(args, 'templateKey');
+          if (anonymousTemplateCatalog) {
+            const storeTemplate = Array.isArray(anonymousTemplateCatalog.storeTemplates)
+              ? anonymousTemplateCatalog.storeTemplates.find((template) => template?.key === templateKey)
+              : null;
+            return storeTemplate
+              ? textResult(storeTemplateDetailProjection({ storeTemplate }))
+              : errorResult(`Practice template not found: ${templateKey}`);
+          }
           const response = await fleetRequest(
             name,
             'GET',
@@ -2969,8 +3158,15 @@ export function createTools(config) {
           const response = await fleetRequest(name, 'GET', path, undefined, { workspaceId });
           return 'error' in response ? response.error : textResult(secretSafe(response.value));
         }
+        case 'sample_store_reset': {
+          const response = await fleetRequest(name, 'POST', '/practice/worlds/sample/reset', {});
+          return 'error' in response ? response.error : textResult(secretSafe(response.value));
+        }
         case 'workspaces_list': {
-          const response = await fleetRequest(name, 'GET', '/workspaces');
+          const limit = args.limit === undefined ? 100 : optionalPositiveInteger(args, 'limit');
+          if (limit > 100) throw new Error('limit must be 100 or fewer');
+          const cursor = args.cursor === undefined ? undefined : requiredString(args, 'cursor');
+          const response = await fleetRequest(name, 'GET', queryPath('/workspaces', { limit, cursor }));
           return 'error' in response ? response.error : textResult(secretSafe(response.value));
         }
         case 'workspace_create': {
@@ -3023,7 +3219,10 @@ export function createTools(config) {
           const action = branch.action;
           let response;
           if (action === 'list') {
-            response = await fleetRequest(name, 'GET', '/catalog-slices', undefined, {
+            const limit = args.limit === undefined ? 100 : optionalPositiveInteger(args, 'limit');
+            if (limit > 100) throw new Error('limit must be 100 or fewer');
+            const cursor = args.cursor === undefined ? undefined : requiredString(args, 'cursor');
+            response = await fleetRequest(name, 'GET', queryPath('/catalog-slices', { limit, cursor }), undefined, {
               workspaceId, invocationMutates: branch.mutates,
             });
           } else if (action === 'save') {
@@ -3386,11 +3585,16 @@ export function createTools(config) {
             );
           }
           const started = response.json ?? {};
+          const attemptId = started.attemptId ?? started.practiceRun?.attemptId;
+          const consoleFields = await practiceRunConsoleUrlFields(attemptId, workspaceId);
           return textResult(secretSafe({
             operation: 'start',
-            attemptId: started.attemptId ?? started.practiceRun?.attemptId,
+            attemptId,
+            ...(started.teaching ? { teaching: started.teaching } : {}),
             ...(started.segmentPlan ? { segmentPlan: started.segmentPlan } : {}),
             ...(started.assertionPlan ? { assertionPlan: started.assertionPlan } : {}),
+            ...railBrief(started.brief),
+            ...(started.nextStep && typeof started.nextStep === 'object' ? { nextStep: started.nextStep } : {}),
             practiceRun: practiceRunProjection(started.practiceRun),
             paths: {
               state: started.statePath,
@@ -3398,11 +3602,14 @@ export function createTools(config) {
               advance: started.advancePath,
               report: started.reportPath,
             },
-            ...consoleUrlFields(started.consoleRef, started.consoleRefExpiresAt),
+            ...consoleFields,
           }));
         }
         case 'practice_runs_list': {
           const workspaceId = optionalWorkspaceId(args);
+          const limit = optionalPositiveInteger(args, 'limit') ?? 100;
+          if (limit > 100) throw new Error('limit must be 100 or less');
+          const cursor = args.cursor === undefined ? undefined : requiredString(args, 'cursor');
           const requestedStoreId = args.storeId === undefined
             ? undefined
             : validatedStoreId(requiredString(args, 'storeId'), 'storeId');
@@ -3423,7 +3630,7 @@ export function createTools(config) {
             if (requestedStoreId && requestedStoreId !== receiptStoreId) {
               return practiceRunReceiptStoreMismatch(receiptId, receiptStoreId, requestedStoreId);
             }
-            const listPath = queryPath('/practice/playbacks', { worldId: receiptStoreId });
+            const listPath = queryPath('/practice/playbacks', { worldId: receiptStoreId, limit, cursor, detail: 'card' });
             const listed = await fleetRequest(name, 'GET', listPath, undefined, { workspaceId });
             if ('error' in listed) return listed.error;
             return textResult(practiceRunsProjection(listed.value, receiptStoreId, 'receipt-derived', workspaceId));
@@ -3442,7 +3649,8 @@ export function createTools(config) {
             return practiceRunsSelectionError(storeIds);
           }
 
-          const listPath = queryPath('/practice/playbacks', { worldId: requestedStoreId ?? storeIds[0] });
+          // MEG-1571: the completed rows of this one call carry the server-owned comparison cards.
+          const listPath = queryPath('/practice/playbacks', { worldId: requestedStoreId ?? storeIds[0], limit, cursor, detail: 'card' });
           const listed = await fleetRequest(name, 'GET', listPath, undefined, { workspaceId });
           if ('error' in listed) return listed.error;
           const selectedStoreId = requestedStoreId ?? storeIds[0];
@@ -3464,11 +3672,14 @@ export function createTools(config) {
             return practiceErrorResult(response.status, response.json, response.retryAfterSeconds, teaching);
           }
           const state = response.json ?? {};
+          const consoleFields = await practiceRunConsoleUrlFields(attemptId, workspaceId);
           return textResult(secretSafe({
             operation: 'status',
             attemptId,
+            ...railBrief(state.brief),
+            ...(state.nextStep && typeof state.nextStep === 'object' ? { nextStep: state.nextStep } : {}),
             practiceRun: practiceRunProjection(state.practiceRun),
-            ...consoleUrlFields(state.consoleRef, state.consoleRefExpiresAt),
+            ...consoleFields,
           }));
         }
         case 'practice_run_checkpoint': {
@@ -3481,13 +3692,16 @@ export function createTools(config) {
               : undefined;
             return practiceErrorResult(response.status, response.json, response.retryAfterSeconds, teaching);
           }
+          const consoleFields = await practiceRunConsoleUrlFields(attemptId, workspaceId);
           return textResult(secretSafe({
             operation: 'checkpoint',
             attemptId,
             alreadyCaptured: response.json?.alreadyCaptured === true,
             advanceCursor: response.json?.advanceCursor,
             checkpoint: checkpointProjection(response.json?.checkpoint),
-            ...consoleUrlFields(response.json?.consoleRef, response.json?.consoleRefExpiresAt),
+            ...railBrief(response.json?.brief),
+            ...(response.json?.nextStep && typeof response.json.nextStep === 'object' ? { nextStep: response.json.nextStep } : {}),
+            ...consoleFields,
           }));
         }
         case 'practice_run_advance': {
@@ -3511,6 +3725,7 @@ export function createTools(config) {
             return practiceErrorResult(response.status, response.json, response.retryAfterSeconds, teaching);
           }
           const advanced = response.json ?? {};
+          const consoleFields = await practiceRunConsoleUrlFields(attemptId, workspaceId);
           return textResult(secretSafe({
             operation: 'advance',
             attemptId,
@@ -3518,8 +3733,10 @@ export function createTools(config) {
             isComplete: advanced.isComplete,
             alreadyApplied: advanced.alreadyApplied === true,
             ...(advanced.until ? { until: advanced.until } : {}),
+            ...railBrief(advanced.brief),
+            ...(advanced.nextStep && typeof advanced.nextStep === 'object' ? { nextStep: advanced.nextStep } : {}),
             practiceRun: practiceRunProjection(advanced.practiceRun),
-            ...consoleUrlFields(advanced.consoleRef, advanced.consoleRefExpiresAt),
+            ...consoleFields,
           }));
         }
         case 'practice_run_finish': {
@@ -3537,33 +3754,42 @@ export function createTools(config) {
               : undefined;
             return practiceErrorResult(response.status, response.json, response.retryAfterSeconds, teaching);
           }
+          const consoleFields = await practiceRunConsoleUrlFields(attemptId, workspaceId);
           return textResult(secretSafe({
             operation: 'finish',
             attemptId,
+            ...railBrief(response.json?.brief),
+            ...(response.json?.nextStep && typeof response.json.nextStep === 'object' ? { nextStep: response.json.nextStep } : {}),
             practiceRun: practiceRunProjection(response.json),
-            ...consoleUrlFields(response.json?.consoleRef, response.json?.consoleRefExpiresAt),
+            ...consoleFields,
           }));
         }
         case 'practice_run_report': {
           const attemptId = requiredPracticeAttemptId(args);
           const workspaceId = optionalWorkspaceId(args);
-          const response = await practiceApi('GET', `/practice/playbacks/${encodeURIComponent(attemptId)}/report?v=2`, undefined, { workspaceId });
+          const detail = requiredReceiptDetail(args);
+          const response = await practiceApi('GET', `/practice/playbacks/${encodeURIComponent(attemptId)}/report?v=2&detail=${detail}`, undefined, { workspaceId });
           if (!response.ok) {
             const teaching = isPracticeRunUnavailable(response.status, response.json)
               ? practiceRunUnavailableTeaching(name, attemptId)
               : undefined;
             return practiceErrorResult(response.status, response.json, response.retryAfterSeconds, teaching);
           }
+          // MEG-1571: the default reply is the server-owned comparison card, passed through exactly
+          // as the API emitted it. Only the full document keeps the MCP receipt projection.
+          if (detail === 'card') return textResult(response.json ?? {});
+          const consoleFields = await practiceRunConsoleUrlFields(attemptId, workspaceId);
           return textResult({
             operation: 'report',
             ...receiptProjection(response.json ?? {}),
-            ...consoleUrlFields(response.json?.consoleRef, response.json?.consoleRefExpiresAt),
+            ...consoleFields,
           });
         }
         case 'practice_run_impact': {
           const attemptId = requiredPracticeAttemptId(args);
           const workspaceId = optionalWorkspaceId(args);
-          const response = await practiceApi('GET', `/practice/playbacks/${encodeURIComponent(attemptId)}/impact`, undefined, { workspaceId });
+          const detail = requiredReceiptDetail(args);
+          const response = await practiceApi('GET', `/practice/playbacks/${encodeURIComponent(attemptId)}/impact?detail=${detail}`, undefined, { workspaceId });
           if (!response.ok) {
             const teaching = isPracticeRunUnavailable(response.status, response.json)
               ? practiceRunUnavailableTeaching(name, attemptId)
@@ -3572,21 +3798,30 @@ export function createTools(config) {
           }
           // T1 owns the shape and the API already ran the public-safe scan; pass it through verbatim
           // (no array truncation) rather than re-projecting.
+          if (detail === 'card') return textResult(response.json ?? {});
           return textResult({ operation: 'impact', ...(response.json ?? {}) });
         }
         case 'get_connection_details': {
           const requestedStoreId = requiredPracticeStoreId(args);
           const workspaceId = optionalWorkspaceId(args);
-          let details;
-          try {
-            details = await api('GET', `/practice/${encodeURIComponent(requestedStoreId)}/connection`, undefined, { auth: true, workspaceId });
-          } catch (error) {
-            if (error instanceof ToolResultError) throw error;
-            if (error instanceof Error && error.message.startsWith('404 ')) {
-              return practiceStoreConnectionNotFoundGuidance(requestedStoreId);
+          const response = await apiRaw(
+            'GET',
+            `/practice/${encodeURIComponent(requestedStoreId)}/connection`,
+            undefined,
+            { workspaceId, cacheBustRead: true },
+          );
+          if (!response.ok) {
+            const authenticationError = authenticationErrorResult(response.status, response.json);
+            if (authenticationError) return authenticationError;
+            if (response.status === 404) {
+              return practiceStoreConnectionNotFoundGuidance(requestedStoreId, response.json?.nextStep);
             }
-            throw error;
+            return {
+              content: [{ type: 'text', text: JSON.stringify(secretSafe(response.json), null, 2) }],
+              isError: true,
+            };
           }
+          const details = response.json;
           const storeId = details.storeId ?? requestedStoreId;
           const shopDomain = details.host ?? `${requestedStoreId}.meguro.io`;
           return textResult({
@@ -3601,6 +3836,9 @@ export function createTools(config) {
             adminVersions: details.admin?.versions,
             adminVersionPolicy: details.adminVersionPolicy ?? details.admin?.supportPolicy,
             adminExecutionGuide: details.adminExecutionGuide,
+            ...(details.nextStep && typeof details.nextStep === 'object'
+              ? { nextStep: details.nextStep }
+              : {}),
             env: {
               SHOPIFY_ADMIN_GRAPHQL_URL: details.adminUrl,
               SHOPIFY_ADMIN_ACCESS_TOKEN: details.token,
@@ -3647,6 +3885,7 @@ export function createTools(config) {
               lookup: requiredString(args, 'lookup'),
               name: requiredString(args, 'name'),
               ...(args.apiVersion !== undefined ? { apiVersion: args.apiVersion } : {}),
+              ...(args.storeId !== undefined ? { storeId: requiredString(args, 'storeId') } : {}),
             };
           return textResult(await api('POST', '/practice/admin-schema', body, { auth: true }));
         }