@adhdev/daemon-core 0.9.82-rc.486 → 0.9.82-rc.487

package/dist/mesh/mesh-refine-gates.d.ts

@@ -11,6 +11,7 @@
  * keep working. `CommandRouterResult` is imported type-only from router.ts
  * (erased at compile time — no runtime import cycle).
  */
+import type { ChangedPackageClassification } from '../git/git-status.js';
 import type { WorktreeBootstrapState } from '../mesh/worktree-bootstrap-config.js';
 import type { CommandRouterResult } from '../commands/router.js';
 export type MeshCoordinatorConfigFormat = 'claude_mcp_json' | 'hermes_config_yaml';
@@ -53,6 +54,19 @@ type MeshRefineValidationSummary = {
     };
     /** M2-2: deprecation notices from the refine config (e.g. bootstrapCommands). */
     deprecationWarnings?: string[];
+    /**
+     * Coarse daemon-vs-web change-impact used to scope the validation command set.
+     * When `isDaemonAffecting === false`, daemon-scoped commands are recorded in
+     * `commandsRun` with `skipped: true, skipReason: 'unaffected_daemon_scope'`
+     * rather than executed; web + typecheck commands always run. Absent when no
+     * change-impact was threaded in (legacy: full command set runs).
+     */
+    changeImpact?: {
+        isDaemonAffecting: boolean;
+        affectedPackages: string[];
+        /** displayCommands skipped because the daemon scope is unaffected. */
+        skippedDaemonCommands?: string[];
+    };
 };
 type MeshRefineStageStatus = 'passed' | 'failed' | 'skipped';
 type MeshRefinePatchEquivalenceSummary = {
@@ -277,6 +291,13 @@ export interface RefineContext {
     baseBranch: string;
     baseHead: string;
     branchHead: string;
+    /**
+     * Coarse daemon-vs-web change-impact for baseHead..branchHead, resolved in the
+     * resolve_refs stage and threaded into the validation gate to scope its command
+     * set. `undefined` means "could not classify" → the gate fails open and runs ALL
+     * commands (never skip on uncertainty).
+     */
+    changeImpact?: ChangedPackageClassification;
     validationSummary: Awaited<ReturnType<typeof runMeshRefineValidationGate>>;
     patchEquivalence: Awaited<ReturnType<typeof runMeshRefinePatchEquivalenceGate>>;
     submoduleReachability: Awaited<ReturnType<typeof runMeshRefineSubmoduleReachabilityGate>>;
@@ -424,5 +445,13 @@ export declare function runMeshRefineValidationGate(mesh: any, workspace: string
     persistedBootstrapState?: WorktreeBootstrapState | null;
     /** M2-2: called after an inherit-mode bootstrap run so the caller can persist the new state. */
     onBootstrapStateChange?: (state: WorktreeBootstrapState) => void;
+    /**
+     * Coarse daemon-vs-web change-impact for the branch (resolve_refs computes it
+     * over baseHead..branchHead). When provided and `isDaemonAffecting === false`,
+     * daemon-scoped validation commands are skipped (web + typecheck still run).
+     * When omitted or `isDaemonAffecting === true`, the full command set runs —
+     * fail-open to full validation on any uncertainty.
+     */
+    changeImpact?: ChangedPackageClassification;
 }): Promise<MeshRefineValidationSummary>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.486",
+  "version": "0.9.82-rc.487",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.486",
-    "@adhdev/session-host-core": "0.9.82-rc.486",
+    "@adhdev/mesh-shared": "0.9.82-rc.487",
+    "@adhdev/session-host-core": "0.9.82-rc.487",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/router-refine.ts

@@ -17,6 +17,8 @@ import { handleMeshForwardEvent, queuePendingMeshCoordinatorEvent } from '../mes
 import { analyzeMeshRefineNodeChangeArea, orderMeshRefineBatchNodes } from '../mesh/mesh-refine-batch.js';
 import type { WorktreeBootstrapState } from '../mesh/worktree-bootstrap-config.js';
 import { DEFAULT_MESH_POLICY } from '../repo-mesh-types.js';
+import { classifyChangedPackages } from '../git/git-status.js';
+import type { ChangedPackageClassification } from '../git/git-status.js';
 import { readStringValue } from '../mesh/mesh-node-identity.js';
 import {
     alignRefinerySubmodulesAfterMerge,
@@ -312,7 +314,24 @@ export async function refineResolveRefsStage(self: DaemonCommandRouter,
             const { stdout: branchHeadStdout } = await execFileAsync('git', ['rev-parse', branch], { cwd: node.workspace, encoding: 'utf8' });
             const baseHead = baseHeadRaw;
             const branchHead = branchHeadStdout.trim();
-            recordMeshRefineStage(refineStages, 'resolve_refs', 'passed', resolveStarted, { branch, baseBranch, baseHead, branchHead, ...(fetchWarning ? { fetchWarning } : {}) });
+
+            // Coarse daemon-vs-web change-impact for baseHead..branchHead, computed
+            // against the worktree so the same policy (.adhdev/change-impact.*) as the
+            // stale-build detector applies. Threaded onto ctx so the validation gate
+            // can scope its command set: a web-only branch skips daemon-scoped commands.
+            // FAIL-OPEN: any classification error leaves changeImpact undefined → the
+            // gate runs the full command set (never skip on uncertainty).
+            let changeImpact: ChangedPackageClassification | undefined;
+            try {
+                changeImpact = await classifyChangedPackages(node.workspace, baseHead, branchHead);
+            } catch {
+                changeImpact = undefined;
+            }
+            recordMeshRefineStage(refineStages, 'resolve_refs', 'passed', resolveStarted, {
+                branch, baseBranch, baseHead, branchHead,
+                ...(changeImpact ? { changeImpact } : {}),
+                ...(fetchWarning ? { fetchWarning } : {}),
+            });
 
             return {
                 kind: 'continue',
@@ -330,6 +349,7 @@ export async function refineResolveRefsStage(self: DaemonCommandRouter,
                     baseBranch,
                     baseHead,
                     branchHead,
+                    changeImpact,
                     validationSummary: undefined as any,
                     patchEquivalence: undefined as any,
                     submoduleReachability: undefined as any,
@@ -346,6 +366,9 @@ export async function refineValidationStage(self: DaemonCommandRouter, ctx: Refi
             const { mesh, node, branch, baseBranch, refineStages } = ctx;
             const validationStarted = Date.now();
             const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace, {
+                // (a) Scope the validation command set by coarse change-impact (resolved
+                // in resolve_refs). Undefined → gate runs the full command set (fail-open).
+                changeImpact: ctx.changeImpact,
                 // M2-2: consume the node's persisted bootstrap state; persist re-runs.
                 persistedBootstrapState: (node as any).worktreeBootstrap as WorktreeBootstrapState | undefined,
                 onBootstrapStateChange: (state) => {
@@ -369,7 +392,9 @@ export async function refineValidationStage(self: DaemonCommandRouter, ctx: Refi
                     : undefined;
                 const buildValidationFailedError = (): string => {
                     const base = validationSummary.failureCode === 'missing_dependencies'
-                        ? 'Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation.'
+                        ? 'Refinery validation dependencies are missing for a change-affected package; merge/refine was not attempted. '
+                            + 'To make this self-service, either (1) configure .adhdev/worktree_bootstrap.json (or validation.bootstrapCommands in .adhdev/refine.json) so Refinery installs deps before validation, '
+                            + 'or (2) converge the branch via the documented manual fast-forward-only bypass (rebase onto the fetched base, verify strict ancestry, then push ff-only) instead of the refine gate.'
                         : validationSummary.failureCode === 'dependency_bootstrap_failed'
                             ? 'Refinery dependency/bootstrap command failed; merge/refine was not attempted.'
                             : validationSummary.failureCode === 'spawn_resolution_failed'

package/src/git/git-status.ts

@@ -438,6 +438,54 @@ function isNonRuntimeRootFile(file: string, policy: ResolvedChangeImpactPolicy):
   return false;
 }
 
+/** Coarse change-impact verdict produced from a changed-file list. */
+export interface ChangedPackageClassification {
+  isDaemonAffecting: boolean;
+  affectedPackages: string[];
+}
+
+/**
+ * Pure bucketer: classify an already-collected changed-file list into the coarse
+ * daemon-vs-web verdict, per the resolved policy. Shared by classifyDaemonBuildChange
+ * (buildCommit..HEAD) and classifyChangedPackages (arbitrary ref range) so the
+ * daemon/web boundary logic lives in exactly one place. An empty list stays
+ * conservative (daemon-affecting) so an actionable warning is never suppressed.
+ */
+function classifyChangedFileList(
+  files: string[],
+  policy: ResolvedChangeImpactPolicy,
+): ChangedPackageClassification {
+  if (files.length === 0) {
+    // No file diff (e.g. only merge metadata) — nothing actionable, but stay
+    // conservative and treat as daemon-affecting so we don't suppress a real warning.
+    return { isDaemonAffecting: true, affectedPackages: [] };
+  }
+  const pkgs = new Set<string>();
+  // A non-package path that is NOT a recognized benign root file (marker/doc).
+  // Only these force daemon-affecting; benign markers/docs are ignored so a
+  // gitlink-moving root commit over a marker-only oss commit no longer over-warns.
+  let sawRuntimeAmbiguousNonPackage = false;
+  for (const file of files) {
+    const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
+    if (!match) {
+      if (!isNonRuntimeRootFile(file, policy)) sawRuntimeAmbiguousNonPackage = true;
+      continue;
+    }
+    pkgs.add(match[1]);
+  }
+  const affectedPackages = [...pkgs].sort();
+  // Daemon-affecting if: any runtime-ambiguous non-package file changed, any
+  // unknown package changed, or any explicit daemon-runtime package changed.
+  // The daemon is unaffected only when every changed file is either a known
+  // web-only package or a recognized benign root file (and at least one such
+  // file changed) — i.e. nothing runtime-ambiguous remains. Unlisted/new packages
+  // therefore stay daemon-affecting (fail-safe default preserved).
+  const allBenign =
+    !sawRuntimeAmbiguousNonPackage &&
+    affectedPackages.every((p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p));
+  return { isDaemonAffecting: !allBenign, affectedPackages };
+}
+
 /**
  * Determine whether the changes between buildCommit..HEAD touch any daemon-runtime
  * package, per the resolved policy. Returns isDaemonAffecting:true conservatively
@@ -449,47 +497,54 @@ async function classifyDaemonBuildChange(
   buildCommit: string,
   options: GitStatusOptions,
   policy: ResolvedChangeImpactPolicy,
-): Promise<{ isDaemonAffecting: boolean; affectedPackages: string[] }> {
+): Promise<ChangedPackageClassification> {
   try {
     const diff = await runGit(repoPath, ['diff', '--name-only', `${buildCommit}..HEAD`], options);
     const files = diff.stdout
       .split('\n')
       .map((line) => line.trim())
       .filter(Boolean);
-    if (files.length === 0) {
-      // No file diff (e.g. only merge metadata) — nothing actionable, but stay
-      // conservative and treat as daemon-affecting so we don't suppress a real warning.
-      return { isDaemonAffecting: true, affectedPackages: [] };
-    }
-    const pkgs = new Set<string>();
-    // A non-package path that is NOT a recognized benign root file (marker/doc).
-    // Only these force daemon-affecting; benign markers/docs are ignored so a
-    // gitlink-moving root commit over a marker-only oss commit no longer over-warns.
-    let sawRuntimeAmbiguousNonPackage = false;
-    for (const file of files) {
-      const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
-      if (!match) {
-        if (!isNonRuntimeRootFile(file, policy)) sawRuntimeAmbiguousNonPackage = true;
-        continue;
-      }
-      pkgs.add(match[1]);
-    }
-    const affectedPackages = [...pkgs].sort();
-    // Daemon-affecting if: any runtime-ambiguous non-package file changed, any
-    // unknown package changed, or any explicit daemon-runtime package changed.
-    // The daemon is unaffected only when every changed file is either a known
-    // web-only package or a recognized benign root file (and at least one such
-    // file changed) — i.e. nothing runtime-ambiguous remains.
-    const allBenign =
-      !sawRuntimeAmbiguousNonPackage &&
-      affectedPackages.every((p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p));
-    return { isDaemonAffecting: !allBenign, affectedPackages };
+    return classifyChangedFileList(files, policy);
   } catch {
     // diff probe failed → can't prove web-only; stay conservative.
     return { isDaemonAffecting: true, affectedPackages: [] };
   }
 }
 
+/**
+ * Ref-parameterized change-impact classification for a repo/worktree, reusing the
+ * exact daemon-vs-web bucketing that the stale-build detector uses — but over an
+ * arbitrary `fromRef..toRef` range (e.g. a refine base head → branch head) instead
+ * of the live daemon's build commit → HEAD, and WITHOUT any daemonBuildInfo caching.
+ *
+ * Policy is resolved the same way as getGitRepoStatus: an explicit
+ * `options.changeImpactConfig` wins; otherwise the repo's `.adhdev/change-impact.*`
+ * is auto-loaded; otherwise the built-in ADHDev default policy applies. The
+ * classification uses `git diff --name-only fromRef..toRef`.
+ *
+ * FAIL-OPEN on error: if the diff can't be collected (bad ref, not a repo), the
+ * caller should treat "no verdict" as "run everything" — so we throw rather than
+ * returning a misleading benign verdict. Callers wrap this in try/catch and leave
+ * changeImpact undefined on failure. Unclassified/new packages still default to
+ * isDaemonAffecting:true (never silently skipped).
+ */
+export async function classifyChangedPackages(
+  repoPath: string,
+  fromRef: string,
+  toRef: string,
+  options: GitStatusOptions = {},
+): Promise<ChangedPackageClassification> {
+  const repo = await resolveGitRepository(repoPath, options);
+  const { config } = resolveChangeImpactConfigForRepo(repo.repoRoot, options);
+  const policy = resolveChangeImpactPolicy(config);
+  const diff = await runGit(repoPath, ['diff', '--name-only', `${fromRef}..${toRef}`], options);
+  const files = diff.stdout
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return classifyChangedFileList(files, policy);
+}
+
 /**
  * Resolve the Change Impact config to apply for this status read. Priority:
  *   - options.changeImpactConfig === null → force built-in default policy (no load).

package/src/mesh/mesh-refine-gates.ts

@@ -13,6 +13,7 @@
  */
 
 import { getGitRepoStatus } from '../git/git-status.js';
+import type { ChangedPackageClassification } from '../git/git-status.js';
 import * as yaml from 'js-yaml';
 import { loadMeshRefineConfig, resolveMeshRefineValidationPlan } from '../mesh/refine-config.js';
 import type { MeshRefineValidationCommandPlan } from '../mesh/refine-config.js';
@@ -74,6 +75,19 @@ type MeshRefineValidationSummary = {
     };
     /** M2-2: deprecation notices from the refine config (e.g. bootstrapCommands). */
     deprecationWarnings?: string[];
+    /**
+     * Coarse daemon-vs-web change-impact used to scope the validation command set.
+     * When `isDaemonAffecting === false`, daemon-scoped commands are recorded in
+     * `commandsRun` with `skipped: true, skipReason: 'unaffected_daemon_scope'`
+     * rather than executed; web + typecheck commands always run. Absent when no
+     * change-impact was threaded in (legacy: full command set runs).
+     */
+    changeImpact?: {
+        isDaemonAffecting: boolean;
+        affectedPackages: string[];
+        /** displayCommands skipped because the daemon scope is unaffected. */
+        skippedDaemonCommands?: string[];
+    };
 };
 
 type MeshRefineStageStatus = 'passed' | 'failed' | 'skipped';
@@ -343,6 +357,13 @@ export interface RefineContext {
     baseBranch: string;
     baseHead: string;
     branchHead: string;
+    /**
+     * Coarse daemon-vs-web change-impact for baseHead..branchHead, resolved in the
+     * resolve_refs stage and threaded into the validation gate to scope its command
+     * set. `undefined` means "could not classify" → the gate fails open and runs ALL
+     * commands (never skip on uncertainty).
+     */
+    changeImpact?: ChangedPackageClassification;
     validationSummary: Awaited<ReturnType<typeof runMeshRefineValidationGate>>;
     patchEquivalence: Awaited<ReturnType<typeof runMeshRefinePatchEquivalenceGate>>;
     submoduleReachability: Awaited<ReturnType<typeof runMeshRefineSubmoduleReachabilityGate>>;
@@ -1477,6 +1498,14 @@ export async function runMeshRefineValidationGate(
         persistedBootstrapState?: WorktreeBootstrapState | null;
         /** M2-2: called after an inherit-mode bootstrap run so the caller can persist the new state. */
         onBootstrapStateChange?: (state: WorktreeBootstrapState) => void;
+        /**
+         * Coarse daemon-vs-web change-impact for the branch (resolve_refs computes it
+         * over baseHead..branchHead). When provided and `isDaemonAffecting === false`,
+         * daemon-scoped validation commands are skipped (web + typecheck still run).
+         * When omitted or `isDaemonAffecting === true`, the full command set runs —
+         * fail-open to full validation on any uncertainty.
+         */
+        changeImpact?: ChangedPackageClassification;
     },
 ): Promise<MeshRefineValidationSummary> {
     const { execFile } = await import('node:child_process');
@@ -1574,6 +1603,63 @@ export async function runMeshRefineValidationGate(
         return ['package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb', 'bun.lock']
             .some(lock => fs.existsSync(pathJoin(cwd, lock)));
     };
+    // A validation command needs installed node_modules to run. Only these can hit
+    // the missing-deps hard-block; non-package-manager commands (e.g. a plain
+    // `node scripts/check-vendor-drift.mjs`) need no deps and must never be aborted
+    // by a preceding command's missing-deps.
+    const needsNodeModules = (candidate: MeshRefineValidationCommand, cwd: string): boolean =>
+        isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
+
+    // (a) Coarse change-impact scoping. When the branch is web-only
+    // (changeImpact.isDaemonAffecting === false), daemon-scoped validation commands
+    // are pointless — and often un-runnable in a web-only worktree that never
+    // bootstrapped daemon deps. Identify daemon-scoped commands ONLY by the coarse
+    // daemon-vs-web bucket: a command whose script/args reference a daemon package
+    // (daemon-core / daemon-cloud) or the vendor-drift check. web-side commands
+    // (test:web-core / test:web-cloud) and `typecheck` ALWAYS run — the daemon/web
+    // boundary is the human-curated safe line; we deliberately do NOT do fine
+    // per-package skipping (web-cloud consumes web-core, so it must still run).
+    const isDaemonScopedCommand = (candidate: MeshRefineValidationCommand): boolean => {
+        const haystack = [candidate.command, ...(candidate.args || []), candidate.displayCommand || '']
+            .join(' ')
+            .toLowerCase();
+        // Never treat a typecheck or an explicit web-side command as daemon-scoped.
+        if (candidate.category === 'typecheck') return false;
+        if (/\btypecheck\b/.test(haystack)) return false;
+        if (/\bweb-core\b|\bweb-cloud\b|\bweb-standalone\b|\btest:web\b/.test(haystack)) return false;
+        // Daemon-scoped signals: a daemon package name, a daemon test script, or the
+        // vendor-drift check (which validates the daemon vendor bundle).
+        return /\bdaemon-core\b|\bdaemon-cloud\b|\btest:daemon\b|check-vendor-drift/.test(haystack);
+    };
+
+    const scopeUnaffectedDaemon = opts?.changeImpact?.isDaemonAffecting === false;
+    const skippedDaemonCommands: string[] = [];
+    const commandsToRun: MeshRefineValidationCommand[] = [];
+    for (const candidate of selection.commands) {
+        if (scopeUnaffectedDaemon && isDaemonScopedCommand(candidate)) {
+            skippedDaemonCommands.push(candidate.displayCommand);
+            // Record the skip so it's visible in the summary, never silently dropped.
+            summary.commandsRun.push({
+                command: candidate.command,
+                args: candidate.args,
+                displayCommand: candidate.displayCommand,
+                category: candidate.category,
+                source: candidate.source,
+                passed: true,
+                skipped: true,
+                skipReason: 'unaffected_daemon_scope',
+            });
+            continue;
+        }
+        commandsToRun.push(candidate);
+    }
+    if (opts?.changeImpact) {
+        summary.changeImpact = {
+            isDaemonAffecting: opts.changeImpact.isDaemonAffecting,
+            affectedPackages: opts.changeImpact.affectedPackages,
+            ...(skippedDaemonCommands.length ? { skippedDaemonCommands } : {}),
+        };
+    }
 
     if (runLegacyBootstrapCommands) {
         summary.bootstrap = { stage: 'legacy' };
@@ -1619,23 +1705,31 @@ export async function runMeshRefineValidationGate(
         }
     }
 
-    for (const candidate of selection.commands) {
+    // (b) Track a genuine missing-deps block for an AFFECTED command. Instead of
+    // aborting the whole gate at the first missing-deps hit (which also killed
+    // trailing no-dep commands like check-vendor-drift.mjs), we mark the blocked
+    // command and CONTINUE evaluating the rest: commands whose deps are present, or
+    // which need no deps at all, still run. missing_dependencies only becomes the
+    // gate failure if at least one command that truly needed deps could not run.
+    let missingDepsBlocked = false;
+    for (const candidate of commandsToRun) {
         const startedAt = Date.now();
         const cwd = candidate.cwd ? pathResolve(workspace, candidate.cwd) : workspace;
         const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
         const bootstrapProvidedDependencies = summary.bootstrap?.stage === 'cached' || summary.bootstrap?.stage === 'ran' || summary.bootstrap?.stage === 'legacy';
-        if (!bootstrapProvidedDependencies && isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd)) {
+        if (!bootstrapProvidedDependencies && needsNodeModules(candidate, cwd)) {
+            // This command genuinely needs node_modules that are absent. Mark it
+            // blocked, but do NOT abort — a following no-dep command (or one in a
+            // different cwd that DOES have deps) must still get its chance to run.
             summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, {
-                stderr: 'Dependencies appear to be missing: package.json and a lockfile are present, but node_modules is absent. Configure validation.bootstrapCommands in repo mesh/refine config if Refinery should install/bootstrap before validation.',
+                stderr: 'Dependencies appear to be missing: package.json and a lockfile are present, but node_modules is absent. Configure validation.bootstrapCommands (or .adhdev/worktree_bootstrap.json) in repo mesh/refine config if Refinery should install/bootstrap before validation.',
             }, false, {
                 exitCode: null,
                 skipped: true,
                 failureKind: 'missing_dependencies',
             }));
-            summary.status = 'failed';
-            summary.failureKind = 'missing_dependencies';
-            summary.failureCode = 'missing_dependencies';
-            return summary;
+            missingDepsBlocked = true;
+            continue;
         }
         // See the bootstrap loop above: resolve the win32 .cmd shim to an
         // absolute path before handing it to the spawn boundary.
@@ -1681,6 +1775,18 @@ export async function runMeshRefineValidationGate(
         }
     }
 
+    // (b) A command that genuinely needed deps could not run. Surface it as the
+    // gate failure now (after letting no-dep / deps-present commands run), so the
+    // caller can classify it blocked_review and emit a self-service hint. Every
+    // daemon-scoped command in a web-only branch was already filtered above, so a
+    // missing-deps block here is a real affected-command block.
+    if (missingDepsBlocked) {
+        summary.status = 'failed';
+        summary.failureKind = 'missing_dependencies';
+        summary.failureCode = 'missing_dependencies';
+        return summary;
+    }
+
     summary.status = 'passed';
     return summary;
 }