@wix/agent-skills 1.33.0 → 1.34.0

package/skills/wix-replatform/scripts/internal-link-audit.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { census } = require('../lib/link-census.js');
+const { buildLinkPlan } = require('../lib/link-plan.js');
+const { readLinkAudit, writeLinkAudit, linkOperatorActions } = require('../lib/link-audit.js');
+const { verifyLinkAudit } = require('../lib/link-verification.js');
+const { structuredLinkPatch } = require('../lib/structured-link-patch.js');
+const { createLinkWriteJournal } = require('../lib/link-write-journal.js');
+const { inspectRoute, configureRoute } = require('../lib/app-page-routing.js');
+const routeKnowledge = require('../resources/rp-target-wix/app-page-routing-capabilities.json');
+
+function withinProject(projectDir, relative) {
+  const resolved = path.resolve(projectDir, relative);
+  if (!resolved.startsWith(`${projectDir}${path.sep}`)) throw new Error('input must be inside project directory');
+  return resolved;
+}
+
+async function loadJson(file) { return JSON.parse(await fs.readFile(file, 'utf8')); }
+
+async function main() {
+  const [operation, projectArg, inputArg] = process.argv.slice(2);
+  if (!['plan', 'route', 'verify'].includes(operation) || !projectArg || !inputArg) {
+    throw new Error('Usage: internal-link-audit.js <plan|route|verify> <projectDir> <input.json>');
+  }
+  const projectDir = path.resolve(projectArg);
+  const config = await loadJson(withinProject(projectDir, inputArg));
+  if (operation === 'plan') {
+    const previous = await readLinkAudit(projectDir);
+    if (!Array.isArray(config.expectedFiles)) throw new Error('plan input needs the complete captured-file inventory as expectedFiles');
+    const roots = config.capturedRoots.map((item) => withinProject(projectDir, item));
+    const expectedFiles = config.expectedFiles.map((item) => withinProject(projectDir, item));
+    const containingPages = Object.fromEntries(Object.entries(config.containingPages || {}).map(([file, value]) => [withinProject(projectDir, file), value]));
+    const scanned = await census({ capturedRoots: roots, expectedFiles, sourceHosts: config.sourceHosts, destinationHosts: config.destinationHosts, containingPages, previous });
+    const routeFile = path.join(projectDir, 'state/url-preservation/app-page-routes.json');
+    const routes = await loadJson(routeFile).then((row) => row.results).catch((error) => { if (error.code === 'ENOENT') return []; throw error; });
+    const audit = buildLinkPlan({ census: scanned, targets: config.targets, samples: config.samples || [], routes, ownershipDecisions: config.ownershipDecisions || {}, activeWriters: config.activeWriters, previous, runId: config.runId, sourceSnapshot: config.sourceSnapshot, routeRevision: config.routeRevision, deploymentId: config.deploymentId || null, budgetDecision: config.budgetDecision || null });
+    await writeLinkAudit(projectDir, audit);
+    console.log(JSON.stringify({ stage: audit.stage, counts: audit.counts, pending: audit.pendingDestinations.length, unresolved: audit.unresolved.length, operatorActions: linkOperatorActions(audit).map((row) => row.code) }));
+    return;
+  }
+  if (operation === 'route') {
+    const transport = require(withinProject(projectDir, config.transportModule));
+    if (typeof transport.inspectDestination !== 'function' || (await transport.inspectDestination()).isLive !== false) {
+      throw new Error('route configuration requires an inspected non-live migration destination');
+    }
+    const results = [];
+    for (const row of config.routes) {
+      const capability = routeKnowledge.capabilities.find((item) => item.family === row.source.family && item.frontendType === row.frontendType)
+        || { family: row.source.family, frontendType: row.frontendType, supported: false, reason: 'missing-schema-backed-adapter' };
+      const existing = capability.supported ? await transport.read(capability.key, capability) : null;
+      const plan = inspectRoute(row.source, capability, existing);
+      results.push(await configureRoute(plan, capability, transport));
+    }
+    const output = withinProject(projectDir, config.output || 'state/url-preservation/app-page-routes.json');
+    await fs.mkdir(path.dirname(output), { recursive: true });
+    const temporary = `${output}.${process.pid}.tmp`;
+    await fs.writeFile(temporary, `${JSON.stringify({ schemaVersion: 1, results }, null, 2)}\n`);
+    await fs.rename(temporary, output);
+    console.log(JSON.stringify({ routeCount: results.length, configured: results.filter((row) => row.status === 'configured' || row.status === 'reused').length, unresolved: results.filter((row) => !['configured', 'reused'].includes(row.status)).length }));
+    return;
+  }
+  const audit = await readLinkAudit(projectDir);
+  if (!audit) throw new Error('link audit missing; run plan first');
+  const adapter = require(withinProject(projectDir, config.adapterModule));
+  if (typeof adapter.getActiveWriters !== 'function') throw new Error('adapter must provide getActiveWriters');
+  if (typeof adapter.inspectDestination !== 'function' || (await adapter.inspectDestination()).isLive !== false) {
+    throw new Error('link repair requires an inspected non-live migration destination');
+  }
+  const activeWriters = await adapter.getActiveWriters();
+  if (typeof adapter.readRecord !== 'function' || typeof adapter.writeRecord !== 'function' || typeof adapter.checkRenderedLink !== 'function') {
+    throw new Error('verify adapter must provide readRecord, writeRecord and checkRenderedLink; per-occurrence repair callbacks are not accepted');
+  }
+  const recordAdapter = { read: adapter.readRecord.bind(adapter), write: adapter.writeRecord.bind(adapter), patchField: structuredLinkPatch };
+  const result = await verifyLinkAudit(audit, {
+    deploymentId: config.deploymentId, destinationState: 'migration-not-live', activeWriters,
+    checkDestination: adapter.checkDestination, checkSample: adapter.checkSample,
+    recordAdapter, journal: createLinkWriteJournal(projectDir, audit.runId),
+    checkRenderedLink: adapter.checkRenderedLink.bind(adapter), checkFragment: adapter.checkFragment?.bind(adapter),
+    readBackMs: config.readBackMs,
+    writeMs: config.writeMs, writeSource: config.writeSource,
+    sessionCount: config.sessionCount, exceptionTokens: config.exceptionTokens,
+    onCheckpoint: (snapshot) => writeLinkAudit(projectDir, snapshot),
+  });
+  console.log(JSON.stringify({ stage: result.stage, estimate: result.estimate, pending: result.pendingDestinations.length, unresolved: result.unresolved.length, operatorActions: linkOperatorActions(result).map((row) => row.code) }));
+}
+
+main().catch((error) => { console.error(error && error.message || error); process.exitCode = 1; });

package/skills/wix-replatform/scripts/item-seo-tags-verify.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+'use strict';
+const { startDevProbe } = require('../lib/execution-capability');
+
+// A live, end-to-end exercise of the seo/item-seo-tags write
+// path. Reads a WordPress post already seeded with a genuine Yoast override (see
+// scripts/test-site-seed/seed-plugin-data.mjs's 'seo' section), maps it to the Item SEO
+// Tags shape per rp-target-wix/domains/seo/entities/item-seo-tags.json's mappingGuidance,
+// creates a throwaway Wix Blog post to get a real itemId, writes the mapped tags via Bulk
+// Set Item SEO Tags, reads them back to confirm they resolved with TAG_SOURCE_ITEM, and —
+// on every exit path, success or failure — deletes the throwaway post. If cleanup itself
+// fails, the retained itemId is printed rather than swallowed.
+//
+// Usage:
+//   node skills/wix-replatform/scripts/item-seo-tags-verify.js \
+//     --wp-env <path to source.wordpress.env> \
+//     --wix-env <path to target.wix.env> \
+//     --wp-post-id <numeric WordPress post id already seeded with an override> \
+//     [--keep]   # skip cleanup, print the retained itemId instead (debugging only)
+
+const { readEnvFile } = require('../lib/config-env.js');
+const writers = require('../resources/rp-target-wix/lib/wix-writers.js');
+const {
+  createWixClient,
+  createDraftPost,
+  publishDraftPost,
+  deleteDraftPost,
+  listMembers,
+} = writers;
+
+function usage() {
+  return [
+    'Usage: node skills/wix-replatform/scripts/item-seo-tags-verify.js',
+    '  --wp-env <path>       source.wordpress.env (WP_BASE_URL, WP_USERNAME, WP_APPLICATION_PASSWORD)',
+    '  --wix-env <path>      target.wix.env (WIX_SITE_ID, WIX_API_KEY)',
+    '  --wp-post-id <id>     WordPress post id already seeded with a genuine Yoast override',
+    '  [--keep]              skip cleanup; print the retained itemId instead of deleting it',
+  ].join('\n');
+}
+
+function parseArgs(argv) {
+  const args = { keep: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === '--wp-env') args.wpEnvFile = argv[++i];
+    else if (token === '--wix-env') args.wixEnvFile = argv[++i];
+    else if (token === '--wp-post-id') args.wpPostId = argv[++i];
+    else if (token === '--keep') args.keep = true;
+    else throw new Error(`Unexpected argument: ${token}`);
+  }
+  if (!args.wpEnvFile || !args.wixEnvFile || !args.wpPostId) {
+    throw new Error(`Missing required argument(s).\n\n${usage()}`);
+  }
+  return args;
+}
+
+// Same mapping as documented in item-seo-tags.json's mappingGuidance and already dry-run
+// tested against a real WordPress/WooCommerce test site: title/description/og:*/twitter:card carry over;
+// canonical, robots, and schema are deliberately dropped (source-domain / source-artefact /
+// source-shaped, never passed through verbatim — see wordpress-seo.json's pitfalls).
+function mapYoastHeadToItemSeoTags(head, focusKeyword) {
+  const tags = [];
+  if (head.title) tags.push({ type: 'title', children: head.title });
+  if (head.description) tags.push({ type: 'meta', props: { name: 'description', content: head.description } });
+  for (const [key, prop] of [
+    ['og_title', 'og:title'],
+    ['og_description', 'og:description'],
+    ['og_type', 'og:type'],
+    ['og_url', 'og:url'],
+  ]) {
+    if (head[key]) tags.push({ type: 'meta', props: { property: prop, content: head[key] } });
+  }
+  if (Array.isArray(head.og_image) && head.og_image[0]?.url) {
+    tags.push({ type: 'meta', props: { property: 'og:image', content: head.og_image[0].url } });
+  }
+  if (head.twitter_card) tags.push({ type: 'meta', props: { name: 'twitter:card', content: head.twitter_card } });
+  const focusKeywords = focusKeyword ? [{ term: focusKeyword, isMain: true }] : [];
+  return { tags, focusKeywords };
+}
+
+async function fetchWpPost(wpBaseUrl, wpUser, wpAppPassword, postId) {
+  const auth = 'Basic ' + Buffer.from(`${wpUser}:${wpAppPassword.replace(/\s+/g, '')}`).toString('base64');
+  const res = await fetch(`${wpBaseUrl.replace(/\/$/, '')}/wp-json/wp/v2/posts/${postId}?context=edit`, {
+    headers: { Authorization: auth },
+  });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`WordPress read of post ${postId} failed: ${res.status}: ${text.slice(0, 300)}`);
+  return JSON.parse(text);
+}
+
+function minimalRicosDocument(text) {
+  return {
+    nodes: [
+      {
+        type: 'PARAGRAPH',
+        id: '',
+        nodes: [{ type: 'TEXT', id: '', textData: { text, decorations: [] } }],
+      },
+    ],
+  };
+}
+
+// Routed through wix-writers so the STORES_PRODUCT refusal applies here too.
+const bulkSetItemSeoTags = writers.bulkSetItemSeoTags;
+
+async function getItemSeoTags(wix, itemType, itemId) {
+  return wix.send(writers.buildGetItemSeoTagsRequest(itemType, itemId));
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const wpEnv = await readEnvFile(args.wpEnvFile);
+  const wixEnv = await readEnvFile(args.wixEnvFile);
+
+  const wpPost = await fetchWpPost(wpEnv.WP_BASE_URL, wpEnv.WP_USERNAME, wpEnv.WP_APPLICATION_PASSWORD, args.wpPostId);
+  const focusKeyword = wpPost.meta?._yoast_wpseo_focuskw || null;
+  if (!wpPost.meta?._yoast_wpseo_title && !wpPost.meta?._yoast_wpseo_metadesc) {
+    throw new Error(
+      `WordPress post ${args.wpPostId} has no genuine Yoast override (_yoast_wpseo_title/_metadesc are empty) — ` +
+        're-run scripts/test-site-seed/seed-plugin-data.mjs first, or pass an already-seeded post id.',
+    );
+  }
+  const mapped = mapYoastHeadToItemSeoTags(wpPost.yoast_head_json || {}, focusKeyword);
+  const wantedTitle = mapped.tags.find((t) => t.type === 'title')?.children;
+
+  const wix = createWixClient({ authToken: wixEnv.WIX_API_KEY, capability: startDevProbe({ siteId: wixEnv.WIX_SITE_ID, confirmation: process.env.RP_SENTINEL_CONFIRM }) });
+
+  let draftPostId = null;
+  let outcome = { ok: false };
+  try {
+    const memberList = await listMembers(wix, { limit: 1 });
+    const memberId = memberList?.members?.[0]?.id;
+    if (!memberId) {
+      throw new Error(
+        'no member found on the target site to author the throwaway post — the site owner\'s ' +
+          'auto-created user-member should normally be present (see wix-writers.js listMembers comment)',
+      );
+    }
+
+    const draft = await createDraftPost(wix, {
+      title: `[item-seo-tags verification — safe to delete] ${wpPost.slug}`,
+      memberId,
+      richContent: minimalRicosDocument(
+        'Throwaway post created by item-seo-tags-verify.js to live-verify the Bulk Set Item SEO Tags write path. Safe to delete.',
+      ),
+    });
+    draftPostId = draft.id;
+    await publishDraftPost(wix, draftPostId);
+
+    const setResult = await bulkSetItemSeoTags(
+      wix,
+      'BLOG_POST',
+      [
+        {
+          itemId: draftPostId,
+          itemSeoTags: { tags: mapped.tags, focusKeywords: mapped.focusKeywords },
+          fieldMask: ['tags', 'focusKeywords'],
+        },
+      ],
+      { returnEntity: true },
+    );
+
+    const entry = setResult.results?.[0];
+    if (!entry?.itemMetadata?.success) {
+      throw new Error(`Bulk Set Item SEO Tags failed for the entry: ${JSON.stringify(entry?.itemMetadata?.error)}`);
+    }
+
+    const readBack = await getItemSeoTags(wix, 'BLOG_POST', draftPostId);
+    const resolvedTitle = (readBack.resolvedTags || []).find((rt) => rt.tag?.type === 'title');
+    const titleLandedAsItemOverride = resolvedTitle?.source === 'TAG_SOURCE_ITEM' && resolvedTitle.tag?.children === wantedTitle;
+
+    outcome = {
+      ok: titleLandedAsItemOverride,
+      draftPostId,
+      wpPostId: args.wpPostId,
+      mappedTags: mapped.tags,
+      setResult,
+      readBack,
+    };
+  } finally {
+    if (draftPostId && !args.keep) {
+      try {
+        await deleteDraftPost(wix, draftPostId, { permanent: true });
+        outcome.cleanup = 'deleted';
+      } catch (cleanupError) {
+        outcome.cleanup = 'FAILED';
+        outcome.retainedItemId = draftPostId;
+        console.error(
+          `CLEANUP FAILED — throwaway Wix Blog post retained on the target site, itemId=${draftPostId}: ${cleanupError.message}`,
+        );
+      }
+    } else if (draftPostId) {
+      outcome.cleanup = 'skipped (--keep)';
+      outcome.retainedItemId = draftPostId;
+    }
+  }
+
+  console.log(JSON.stringify(outcome, null, 2));
+  if (!outcome.ok) process.exitCode = 1;
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exit(1);
+});

package/skills/wix-replatform/scripts/migration-completion.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs/promises');
+const {
+  COMPLETION_FILE,
+  createMigrationCompletion,
+  loadMigrationCompletionInputs,
+  validateCompletionArtifacts,
+} = require('../lib/migration-completion.js');
+const { validateEntityQaAttestation } = require('../lib/entity-qa-attestation.js');
+const { loadArtifacts, writeJsonAtomic } = require('../lib/orchestration-state.js');
+const { getDecisionValue } = require('../lib/orchestration-decisions.js');
+
+async function main() {
+  const projectDirArg = process.argv[2];
+  if (!projectDirArg) throw new Error('Usage: node scripts/migration-completion.js <projectDir>');
+  const projectDir = path.resolve(projectDirArg);
+  const artifacts = await loadArtifacts(projectDir);
+  const deliveryMode = getDecisionValue(artifacts.decisions || {}, 'deliveryMode');
+  const inputs = await loadMigrationCompletionInputs(projectDir);
+  // Surface the completion-artifact refusals as typed reasons the caller can route on, rather than as a
+  // bare stack trace. The run is not finished until all four artifacts exist; saying which one
+  // is missing is the difference between a fixable stop and a mystery.
+  const artifactCheck = validateCompletionArtifacts(inputs);
+  if (!artifactCheck.ok) {
+    console.error(JSON.stringify({ ok: false, reason: artifactCheck.reason, projectDir }, null, 2));
+    process.exit(1);
+  }
+  // Same treatment for a missing, stale or failed entity-QA attestation -- a typed
+  // refusal carrying `entityQa` (the same object the router's refusal carries), not a bare
+  // "migration cannot complete" thrown out of createMigrationCompletion.
+  const entityQa = validateEntityQaAttestation({
+    attestation: inputs.entityQaAttestation,
+    report: inputs.backendCompletion,
+    reportDigest: inputs.reportDigest,
+    mappedEntities: inputs.mappedEntities,
+  });
+  if (!entityQa.ok) {
+    console.error(JSON.stringify({
+      ok: false,
+      reason: entityQa.reasons[0],
+      entityQa: { qaStatus: entityQa.qaStatus, entities: entityQa.entities, recheck: entityQa.recheck },
+      projectDir,
+    }, null, 2));
+    // The CLI refusal prints the Import Operator prompt with the project path
+    // and affected entities filled in. A missing or stale attestation (recheck: 'full') has no
+    // per-entity list yet -- the whole mapped-entity set needs a fresh pass.
+    const entityList = entityQa.entities.length
+      ? entityQa.entities.map((entry) => `${entry.entity}/${entry.subtype}`).join(', ')
+      : '(all mapped entities -- the attestation is missing or stale)';
+    console.error(
+      `\nImport Operator action required: in project \`${projectDir}\`, run the entity-by-entity QA pass `
+      + 'from `rp-execute-import` against the current completion report, fix the listed entities '
+      + 'through a fresh Developer dispatch, then run `scripts/entity-qa-attestation.js` and re-route.\n'
+      + `qaStatus: ${entityQa.qaStatus}\n`
+      + `Entities to recheck: ${entityList}`,
+    );
+    process.exit(1);
+  }
+  const completion = createMigrationCompletion({ deliveryMode, ...inputs });
+  const outputPath = path.join(projectDir, COMPLETION_FILE);
+  if (inputs.completion?.schemaVersion === 1) {
+    const archive = path.join(projectDir, 'completion/migration-completion.v1.json');
+    // Preserve the original receipt once; never overwrite its historical bytes.
+    await fs.copyFile(outputPath, archive, require('node:fs').constants.COPYFILE_EXCL).catch(error => { if (error.code !== 'EEXIST') throw error; });
+  }
+  await writeJsonAtomic(outputPath, completion);
+  console.log(JSON.stringify({ ok: true, outputPath, completion }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(JSON.stringify({ ok: false, reason: error.code || error.message, staleInputs: error.staleInputs }));
+  process.exit(1);
+});

package/skills/wix-replatform/scripts/orchestration-preflight.js

@@ -3,7 +3,7 @@
 
 const path = require('node:path');
 const { loadArtifacts, writeJsonAtomic } = require('../lib/orchestration-state.js');
-const { runPreflight } = require('../lib/orchestration-preflight.js');
+const { runPreflight, recoverTelemetryJournal, telemetryDimsFromDecisions } = require('../lib/orchestration-preflight.js');
 const { createProgressLogger, parseProgressArgs } = require('../lib/progress-log.js');
 
 let progress;
@@ -11,7 +11,7 @@ let progress;
 async function main() {
   const parsed = parseProgressArgs(process.argv.slice(2));
   progress = createProgressLogger({
-    script: 'skills/replatform/scripts/orchestration-preflight.js',
+    script: 'skills/wix-replatform/scripts/orchestration-preflight.js',
     ...parsed.progress,
   });
   progress.start('Orchestration preflight started', { phase: 'preflight' });
@@ -29,6 +29,7 @@ async function main() {
   }
 
   const result = await runPreflight(projectDir, artifacts, { progress });
+  await recoverTelemetry(projectDir, artifacts, result);
   await writeJsonAtomic(path.join(projectDir, 'orchestration', 'preflight.json'), result);
   console.log(JSON.stringify(result, null, 2));
   if (result.status === 'pass') {
@@ -39,6 +40,24 @@ async function main() {
   process.exit(result.status === 'pass' ? 0 : 1);
 }
 
+// The read-only check has reported what it found; this step recovers. It adds its
+// details to the same `telemetry_journal` check, keeping the original reading, and writes one
+// progress line. It never changes `result.status`, so the verdict and exit code stay exactly as
+// the other checks made them. A failed recovery is recorded here for the RePlatform team only;
+// nothing is printed for the person running the migration.
+async function recoverTelemetry(projectDir, artifacts, result) {
+  const check = result.checks.find((entry) => entry.id === 'telemetry_journal');
+  if (!check) return;
+  const details = await recoverTelemetryJournal(projectDir, check, telemetryDimsFromDecisions(artifacts.decisions || {}));
+  Object.assign(check, details);
+  const fields = { phase: 'preflight', step: 'telemetry-recovery', journal: check.journal, ...details };
+  if (details.recovery === 'failed') {
+    progress.warn('Telemetry recovery failed; the run continues without recording', fields);
+  } else {
+    progress.progress(`Telemetry recovery: ${details.recovery}`, fields);
+  }
+}
+
 main().catch((error) => {
   if (progress) {
     progress.error(error && error.message ? error.message : 'Orchestration preflight failed', { phase: 'preflight' });

package/skills/wix-replatform/scripts/orchestration-route.js

@@ -8,10 +8,40 @@ const { createProgressLogger, parseProgressArgs } = require('../lib/progress-log
 
 let progress;
 
+// Telemetry safety net: record a resumed execution on a stale, open telemetry journal so
+// nobody has to remember `start`. Required lazily inside the guard, so a missing or broken
+// recorder can never fail the route; never touches stdout, stderr or the exit code. Only a
+// resume, a busy lock or an error writes one progress line (team-only, when a progress log is
+// configured); every other no-op is silent.
+async function resumeStaleTelemetry(projectDir) {
+  let telemetryResume;
+  try {
+    const { resumeIfStale } = require('../resources/rp-telemetry/lib/telemetry-recorder.js');
+    telemetryResume = await resumeIfStale(projectDir, { trigger: 'route' });
+  } catch (error) {
+    telemetryResume = { resumed: false, reason: 'error', trigger: 'route', error: String((error && error.message) || error) };
+  }
+  try {
+    const fields = { phase: 'orchestration', step: 'telemetry-resume', ...telemetryResume };
+    if (telemetryResume.reason === 'resumed') {
+      if (['partial', 'failed', 'deadline'].includes(telemetryResume.heal)) {
+        progress.warn('Telemetry resumed a stale journal; BI heal incomplete', fields);
+      } else {
+        progress.progress('Telemetry resumed a stale journal', fields);
+      }
+    } else if (telemetryResume.reason === 'busy' || telemetryResume.reason === 'error') {
+      progress.warn('Telemetry resume did not run', fields);
+    }
+  } catch {
+    // A progress-log failure must not alter the route either.
+  }
+  return telemetryResume;
+}
+
 async function main() {
   const parsed = parseProgressArgs(process.argv.slice(2));
   progress = createProgressLogger({
-    script: 'skills/replatform/scripts/orchestration-route.js',
+    script: 'skills/wix-replatform/scripts/orchestration-route.js',
     ...parsed.progress,
   });
   progress.start('Orchestration route started', { phase: 'orchestration' });
@@ -27,6 +57,7 @@ async function main() {
   if (!artifacts.run) {
     throw new Error(`orchestration artifacts not initialized under ${projectDir}`);
   }
+  await resumeStaleTelemetry(projectDir);
   const result = await determineNextStep(projectDir, artifacts);
   console.log(JSON.stringify(result, null, 2));
   if (result.ok) {