@adhdev/daemon-core 0.9.82-rc.328 → 0.9.82-rc.329

package/dist/mesh/mesh-events-stale.d.ts

@@ -31,7 +31,7 @@ export declare function reconcileDirectDispatchCompletionFromTranscript(args: {
     ledgerEntryId?: string;
     reason?: string;
 };
-export declare function buildLongGeneratingCompletionReconciliation(args: {
+export declare function buildNoProgressCompletionReconciliation(args: {
     meshId: string;
     nodeId?: string;
     nodeLabel: string;

package/dist/providers/status-monitor.d.ts

@@ -3,16 +3,16 @@
  *
  * Common across all Provider categories (IDE/Extension/CLI/ACP).
  * - Approval waiting (waiting_approval) notification
- * - Notification when generating persists for extended duration
+ * - No-progress watchdog: alert when an active turn makes no progress for a while
  * - All config toggleable via Provider Settings
  */
 export interface MonitorConfig {
     /** Enable awaiting-approval notification */
     approvalAlert: boolean;
-    /** Prolonged generating notification enabled */
-    longGeneratingAlert: boolean;
-    /** Prolonged threshold (seconds) */
-    longGeneratingThresholdSec: number;
+    /** No-progress watchdog notification enabled */
+    noProgressAlert: boolean;
+    /** No-progress threshold (seconds) */
+    noProgressThresholdSec: number;
     /** Repeat notification cooldown (seconds) */
     alertCooldownSec: number;
 }
@@ -28,7 +28,7 @@ export declare class StatusMonitor {
     private config;
     private lastAlertTime;
     private generatingStartTimes;
-    private longGeneratingAlerted;
+    private noProgressAlerted;
     private lastProgressFingerprint;
     private lastProgressChangeAt;
     constructor(config?: Partial<MonitorConfig>);
@@ -40,7 +40,7 @@ export declare class StatusMonitor {
      * Check status transition → return notification event array.
      * Called from each onTick() or detectStatusTransition().
      */
-    check(agentKey: string, status: string, now: number, progressFingerprint?: string): MonitorEvent[];
+    check(agentKey: string, status: string, now: number, progressFingerprint?: string, approvalPending?: boolean): MonitorEvent[];
     /** Cooldown check — prevent sending the same notification too frequently */
     private shouldAlert;
     /** Reset (on agent terminate/restart) */

package/dist/shared-types.d.ts

@@ -619,7 +619,7 @@ export interface DashboardBootstrapDaemonEntry extends Partial<CloudDaemonSummar
     p2p?: StatusReportPayload['p2p'];
     timestamp?: number;
 }
-export type DaemonStatusEventName = 'agent:generating_started' | 'agent:waiting_approval' | 'agent:generating_completed' | 'agent:stopped' | 'monitor:long_generating';
+export type DaemonStatusEventName = 'agent:generating_started' | 'agent:waiting_approval' | 'agent:generating_completed' | 'agent:stopped' | 'monitor:no_progress' | 'monitor:long_generating';
 /** Minimal daemon-originated event payload relayed through the server. */
 export interface DaemonStatusEventPayload {
     event: DaemonStatusEventName;

package/package.json

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

package/src/agent-stream/provider-adapter.ts

@@ -256,7 +256,7 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
             }
             const validated = validateReadChatResultPayload(data, `${this.agentType} readChat`);
             const validatedStatus = (validated as any).status as string;
-            const streamStatus = validatedStatus === 'generating' || validatedStatus === 'long_generating'
+            const streamStatus = validatedStatus === 'generating' || validatedStatus === 'no_progress' || validatedStatus === 'long_generating'
                 ? 'streaming'
                 : validatedStatus;
             const state: AgentStreamState = {

package/src/cli-adapters/provider-cli-adapter.ts

@@ -1321,7 +1321,7 @@ export class ProviderCliAdapter implements CliAdapter {
         };
         if (parsedSessionStatus === 'idle' && hasFinalAssistant(parsedStatusBeforeSend)) return null;
         if (this.engine.currentStatus === 'generating') return 'current_status_generating';
-        if (parsedSessionStatus === 'generating' || parsedSessionStatus === 'long_generating') {
+        if (parsedSessionStatus === 'generating' || parsedSessionStatus === 'no_progress' || parsedSessionStatus === 'long_generating') {
             const parsedModal = parsedStatusBeforeSend?.activeModal ?? parsedStatusBeforeSend?.modal ?? null;
             const parsedHasActionableModal = Boolean(
                 parsedModal
@@ -1414,7 +1414,7 @@ export class ProviderCliAdapter implements CliAdapter {
         const parsedSessionStatus = typeof parsedStatusBeforeSend?.status === 'string'
             ? String(parsedStatusBeforeSend.status)
             : '';
-        if (!allowInputDuringGeneration && (parsedSessionStatus === 'generating' || parsedSessionStatus === 'long_generating')) {
+        if (!allowInputDuringGeneration && (parsedSessionStatus === 'generating' || parsedSessionStatus === 'no_progress' || parsedSessionStatus === 'long_generating')) {
             const parsedModal = parsedStatusBeforeSend?.activeModal ?? parsedStatusBeforeSend?.modal ?? null;
             const parsedHasActionableModal = Boolean(
                 parsedModal

package/src/cli-adapters/provider-cli-shared.ts

@@ -62,7 +62,7 @@ export interface CliSessionStatus {
      * Timestamp (ms) of the most recent *visible* terminal screen change.
      * Stricter than lastOutputAt — only advances when the rendered screen
      * content actually differs, so repeated keepalive bytes do not register as
-     * progress. Preferred liveness signal for the long-generating watchdog.
+     * progress. Preferred liveness signal for the no-progress watchdog.
      */
     lastScreenChangeAt?: number;
     bufferState?: {

package/src/commands/chat-commands.ts

@@ -1372,7 +1372,7 @@ function normalizeReadChatCommandStatus(status: unknown, activeModal: unknown):
 }
 
 function isGeneratingLikeStatus(status: unknown): boolean {
-    return status === 'generating' || status === 'streaming' || status === 'long_generating' || status === 'starting';
+    return status === 'generating' || status === 'streaming' || status === 'no_progress' || status === 'long_generating' || status === 'starting';
 }
 
 function hasVisibleAssistantMessage(messages: unknown[] | undefined): boolean {

package/src/commands/cli-manager.ts

@@ -81,7 +81,7 @@ export interface CliManagerDeps {
 
 type CommandResult = { success: boolean;[key: string]: unknown };
 
-const BUSY_AGENT_STATUSES = new Set(['generating', 'running', 'streaming', 'starting', 'busy', 'waiting', 'waiting_approval', 'long_generating']);
+const BUSY_AGENT_STATUSES = new Set(['generating', 'running', 'streaming', 'starting', 'busy', 'waiting', 'waiting_approval', 'no_progress', 'long_generating']);
 const ZERO_MESSAGE_STARTING_SEND_WAIT_MS = 2_000;
 
 function normalizeAgentStatus(value: unknown): string {

package/src/commands/router.ts

@@ -27,6 +27,13 @@ import { listProviderHistorySessions } from '../config/chat-history.js';
 import { detectIDEs } from '../detection/ide-detector.js';
 import { detectCLI, detectCLIs } from '../detection/cli-detector.js';
 import { getGitRepoStatus } from '../git/git-status.js';
+import {
+    CHANGE_IMPACT_CONFIG_LOCATIONS,
+    CHANGE_IMPACT_CONFIG_SCHEMA,
+    loadChangeImpactConfig,
+    suggestChangeImpactConfig,
+    validateChangeImpactConfig,
+} from '../git/change-impact-config.js';
 import {
     normalizeGitStatus as sharedNormalizeGitStatus,
     pickBestTransitGitStatus as sharedPickBestTransitGitStatus,
@@ -7693,6 +7700,45 @@ export class DaemonCommandRouter {
                 };
             }
 
+            case 'get_mesh_change_impact_config_schema': {
+                return {
+                    success: true,
+                    schema: CHANGE_IMPACT_CONFIG_SCHEMA,
+                    locations: CHANGE_IMPACT_CONFIG_LOCATIONS,
+                    sourceOfTruth: 'repo change-impact config',
+                    heuristicRole: 'suggestions_only_not_execution_path',
+                    note: 'Declarative config only — JSON/YAML are parsed but never executed. Defines which package/file changes require a daemon rebuild/restart vs. a web-only redeploy vs. nothing.',
+                };
+            }
+
+            case 'validate_mesh_change_impact_config': {
+                const workspace = typeof args?.workspace === 'string' ? args.workspace : process.cwd();
+                if (args?.config !== undefined) {
+                    const validation = validateChangeImpactConfig(args.config, 'inline');
+                    return { success: validation.valid, source: 'inline', sourceType: 'mesh_policy', ...validation };
+                }
+                const loaded = loadChangeImpactConfig(workspace);
+                if (loaded.sourceType === 'repo_file') {
+                    const validation = validateChangeImpactConfig(loaded.config, loaded.source);
+                    return { success: validation.valid, ...loaded, ...validation };
+                }
+                return {
+                    success: false,
+                    ...loaded,
+                    valid: false,
+                    errors: [loaded.error || 'repo change-impact config unavailable'],
+                };
+            }
+
+            case 'suggest_mesh_change_impact_config': {
+                const workspace = typeof args?.workspace === 'string' ? args.workspace : process.cwd();
+                return {
+                    success: true,
+                    ...suggestChangeImpactConfig(workspace),
+                    note: 'Suggestions are heuristic scaffold only; the draft must be reviewed and saved into repo change-impact config before it takes effect. Nothing is executed.',
+                };
+            }
+
             case 'mesh_init': {
                 const workspace = typeof args?.workspace === 'string' && args.workspace.trim() ? args.workspace.trim() : process.cwd();
                 const mesh = args?.inlineMesh || {};

package/src/git/change-impact-config.ts

@@ -0,0 +1,354 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
+import { join } from 'path';
+import * as yaml from 'js-yaml';
+
+/**
+ * "Change Impact" — config-driven classification of which git changes between the
+ * live daemon's build commit and the workspace HEAD actually require a daemon
+ * rebuild/restart (vs. a web-only redeploy, vs. nothing).
+ *
+ * The daemon-core git surface only knows the FACTS (which files / packages changed
+ * between buildCommit..HEAD). The POLICY — which packages are daemon-runtime, which
+ * are web-only, which root files are non-runtime, and what command to recommend —
+ * is declarative config injected from outside. This keeps git-status.ts repo-agnostic
+ * while preserving ADHDev's exact built-in behavior when no config is present.
+ *
+ * SECURITY: config is declarative only. JSON/YAML are parsed; arbitrary JS config
+ * (.js) is intentionally NOT supported, so loading a config can never execute code.
+ */
+
+/** A change-impact classification bucket. */
+export type ChangeImpactKind = 'daemon' | 'web' | 'none';
+
+/**
+ * Recommended action for a given impact classification. `recommendedAction` is the
+ * stable classification key (always one of daemon|web|none, NOT config-overridable);
+ * config customizes only the human-facing `recommendedCommand` recipe.
+ */
+export interface ChangeImpactTarget {
+    /** Human-facing command/recipe to act on the impact (e.g. deploy + restart). */
+    recommendedCommand: string;
+}
+
+export interface ChangeImpactConfig {
+    /**
+     * Package names (the `<name>` in `packages/<name>/`) whose change means the
+     * daemon runtime is stale and must be rebuilt/redeployed + restarted. When
+     * provided, this REPLACES the built-in daemon-runtime set.
+     */
+    daemonRuntimePackages?: string[];
+    /**
+     * Package names that are web-only — a change to one does not require a daemon
+     * restart, only a web redeploy. When provided, this REPLACES the built-in
+     * web-only set.
+     */
+    webOnlyPackages?: string[];
+    /**
+     * Glob patterns for root-level (non-package) files that demonstrably cannot
+     * change what the daemon runtime executes (markers, docs, license text). These
+     * are added on top of the built-in non-runtime root-file detection.
+     */
+    nonRuntimeRootFilePatterns?: string[];
+    /** Recommended action/command per impact classification. Missing keys fall back to built-in defaults. */
+    impactTargets?: Partial<Record<ChangeImpactKind, ChangeImpactTarget>>;
+}
+
+export interface ChangeImpactConfigLoadResult {
+    config?: ChangeImpactConfig;
+    source: string;
+    sourceType: 'repo_file' | 'unavailable' | 'invalid';
+    path?: string;
+    error?: string;
+    /**
+     * Stable identity of the config SOURCE, used as part of a cache key so a config
+     * edit invalidates any cached impact evaluation. Combines the resolved path and
+     * its mtime (or the path for the unavailable/invalid case).
+     */
+    sourceKey: string;
+}
+
+export const CHANGE_IMPACT_CONFIG_LOCATIONS = [
+    '.adhdev/change-impact.json',
+    '.adhdev/change-impact.yaml',
+    '.adhdev/change-impact.yml',
+    '.adhdev/repo-mesh-change-impact.json',
+    '.adhdev/repo-mesh-change-impact.yaml',
+    '.adhdev/repo-mesh-change-impact.yml',
+];
+
+export const CHANGE_IMPACT_CONFIG_SCHEMA = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    title: 'ADHDev Change Impact Config',
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        daemonRuntimePackages: { type: 'array', items: { type: 'string', minLength: 1 } },
+        webOnlyPackages: { type: 'array', items: { type: 'string', minLength: 1 } },
+        nonRuntimeRootFilePatterns: { type: 'array', items: { type: 'string', minLength: 1 } },
+        impactTargets: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                daemon: { $ref: '#/$defs/target' },
+                web: { $ref: '#/$defs/target' },
+                none: { $ref: '#/$defs/target' },
+            },
+        },
+    },
+    $defs: {
+        target: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['recommendedCommand'],
+            properties: {
+                recommendedCommand: { type: 'string', minLength: 1 },
+            },
+        },
+    },
+} as const;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isStringArray(value: unknown): value is string[] {
+    return Array.isArray(value) && value.every(v => typeof v === 'string' && v.length > 0);
+}
+
+function validateTarget(value: unknown, key: string, errors: string[]): ChangeImpactTarget | undefined {
+    if (!isRecord(value)) {
+        errors.push(`impactTargets.${key} must be an object`);
+        return undefined;
+    }
+    const { recommendedCommand } = value;
+    if (typeof recommendedCommand !== 'string' || !recommendedCommand.length) {
+        errors.push(`impactTargets.${key}.recommendedCommand must be a non-empty string`);
+        return undefined;
+    }
+    // recommendedAction is the fixed classification key; config supplies only the command.
+    for (const k of Object.keys(value)) {
+        if (k !== 'recommendedCommand') errors.push(`impactTargets.${key}.${k} is not a recognized field (only recommendedCommand)`);
+    }
+    return { recommendedCommand };
+}
+
+export function validateChangeImpactConfig(raw: unknown, source = 'inline'): { valid: boolean; errors: string[]; config?: ChangeImpactConfig } {
+    const errors: string[] = [];
+    if (!isRecord(raw)) {
+        return { valid: false, errors: [`${source}: config must be an object`] };
+    }
+    const config: ChangeImpactConfig = {};
+
+    if (raw.daemonRuntimePackages !== undefined) {
+        if (isStringArray(raw.daemonRuntimePackages)) config.daemonRuntimePackages = [...raw.daemonRuntimePackages];
+        else errors.push('daemonRuntimePackages must be an array of non-empty strings');
+    }
+    if (raw.webOnlyPackages !== undefined) {
+        if (isStringArray(raw.webOnlyPackages)) config.webOnlyPackages = [...raw.webOnlyPackages];
+        else errors.push('webOnlyPackages must be an array of non-empty strings');
+    }
+    if (raw.nonRuntimeRootFilePatterns !== undefined) {
+        if (isStringArray(raw.nonRuntimeRootFilePatterns)) config.nonRuntimeRootFilePatterns = [...raw.nonRuntimeRootFilePatterns];
+        else errors.push('nonRuntimeRootFilePatterns must be an array of non-empty strings');
+    }
+    if (raw.impactTargets !== undefined) {
+        if (!isRecord(raw.impactTargets)) {
+            errors.push('impactTargets must be an object');
+        } else {
+            const targets: Partial<Record<ChangeImpactKind, ChangeImpactTarget>> = {};
+            for (const key of Object.keys(raw.impactTargets)) {
+                if (key !== 'daemon' && key !== 'web' && key !== 'none') {
+                    errors.push(`impactTargets.${key} is not a recognized impact kind (daemon|web|none)`);
+                    continue;
+                }
+                const target = validateTarget(raw.impactTargets[key], key, errors);
+                if (target) targets[key as ChangeImpactKind] = target;
+            }
+            if (Object.keys(targets).length) config.impactTargets = targets;
+        }
+    }
+    // Reject unknown top-level keys to catch typos early (mirrors additionalProperties:false).
+    for (const key of Object.keys(raw)) {
+        if (!['daemonRuntimePackages', 'webOnlyPackages', 'nonRuntimeRootFilePatterns', 'impactTargets'].includes(key)) {
+            errors.push(`unknown config key '${key}'`);
+        }
+    }
+
+    return { valid: errors.length === 0, errors, config: errors.length === 0 ? config : undefined };
+}
+
+function parseConfigText(path: string, text: string): unknown {
+    if (/\.json$/i.test(path)) return JSON.parse(text);
+    return yaml.load(text);
+}
+
+/**
+ * Locate and load the Change Impact config for a repo root. Declarative only —
+ * never executes config. Returns a sourceKey suitable for cache invalidation:
+ * config path + mtime, or the sentinel for the missing/invalid case.
+ */
+export function loadChangeImpactConfig(repoRoot: string): ChangeImpactConfigLoadResult {
+    for (const relative of CHANGE_IMPACT_CONFIG_LOCATIONS) {
+        const configPath = join(repoRoot, relative);
+        if (!existsSync(configPath)) continue;
+        try {
+            const text = readFileSync(configPath, 'utf-8');
+            let mtimeMs = 0;
+            try {
+                mtimeMs = statSync(configPath).mtimeMs;
+            } catch {
+                // Best-effort; fall back to content length so edits still perturb the key.
+                mtimeMs = text.length;
+            }
+            const parsed = parseConfigText(configPath, text);
+            const validation = validateChangeImpactConfig(parsed, relative);
+            if (!validation.valid) {
+                return {
+                    source: relative,
+                    sourceType: 'invalid',
+                    path: configPath,
+                    error: validation.errors.join('; '),
+                    sourceKey: `invalid:${configPath}:${mtimeMs}`,
+                };
+            }
+            return {
+                config: validation.config,
+                source: relative,
+                sourceType: 'repo_file',
+                path: configPath,
+                sourceKey: `file:${configPath}:${mtimeMs}`,
+            };
+        } catch (error: any) {
+            return {
+                source: relative,
+                sourceType: 'invalid',
+                path: configPath,
+                error: error?.message || String(error),
+                sourceKey: `error:${configPath}`,
+            };
+        }
+    }
+    return {
+        source: 'unavailable',
+        sourceType: 'unavailable',
+        error: `No change-impact config found. Checked: ${CHANGE_IMPACT_CONFIG_LOCATIONS.join(', ')}`,
+        sourceKey: 'unavailable',
+    };
+}
+
+/**
+ * Translate a config glob pattern into a RegExp matched against a forward-slash
+ * file path. Supports `**` (any path segments), `*` (any chars except `/`), and
+ * `?` (single non-slash char). No brace/character-class expansion — declarative,
+ * minimal, predictable. All other characters are matched literally.
+ */
+export function globToRegExp(pattern: string): RegExp {
+    let out = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                // `**` → any sequence of characters including path separators.
+                out += '.*';
+                i++;
+                // Swallow a trailing slash after `**/` so `**/x` also matches `x`.
+                if (pattern[i + 1] === '/') i++;
+            } else {
+                out += '[^/]*';
+            }
+        } else if (ch === '?') {
+            out += '[^/]';
+        } else if ('.+^${}()|[]\\'.includes(ch)) {
+            out += '\\' + ch;
+        } else {
+            out += ch;
+        }
+    }
+    return new RegExp(`^${out}$`);
+}
+
+export interface ChangeImpactConfigSuggestion {
+    /** A non-executable, declarative config draft a human can save verbatim. */
+    suggestedConfig: ChangeImpactConfig;
+    /** Per-field human-facing rationale for the proposed classification. */
+    notes: string[];
+    /** Package directories discovered under `packages/` (and `oss/packages/`). */
+    discoveredPackages: { daemon: string[]; web: string[]; unclassified: string[] };
+}
+
+function listPackageDirs(packagesRoot: string): string[] {
+    try {
+        return readdirSync(packagesRoot, { withFileTypes: true })
+            .filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
+            .map(entry => entry.name);
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Inspect a repo's package layout and propose a reasonable, declarative Change
+ * Impact config draft. This is heuristic scaffold ONLY — it never executes
+ * anything and the draft must be reviewed/saved by a human before it takes
+ * effect. The heuristic mirrors ADHDev's own conventions:
+ *   - `web-*` / `*-web` packages → web-only (web redeploy, no daemon restart)
+ *   - everything else under packages/ → daemon-runtime (rebuild + restart)
+ *   - docs/license/marker root files → non-runtime
+ * Callers are expected to prune the draft to their actual runtime topology.
+ */
+export function suggestChangeImpactConfig(repoRoot: string): ChangeImpactConfigSuggestion {
+    const notes: string[] = [];
+    const daemon = new Set<string>();
+    const web = new Set<string>();
+    const unclassified: string[] = [];
+
+    const roots = ['packages', join('oss', 'packages')];
+    for (const rel of roots) {
+        const packagesRoot = join(repoRoot, rel);
+        if (!existsSync(packagesRoot)) continue;
+        for (const name of listPackageDirs(packagesRoot)) {
+            if (/(^web[-.]|[-.]web$)/i.test(name) || /dashboard|frontend|ui$/i.test(name)) {
+                web.add(name);
+            } else {
+                daemon.add(name);
+            }
+        }
+    }
+
+    const daemonRuntimePackages = [...daemon].sort();
+    const webOnlyPackages = [...web].sort();
+
+    if (!daemonRuntimePackages.length && !webOnlyPackages.length) {
+        notes.push('No packages/ or oss/packages/ directories found — defaulting to an empty draft you should fill in by hand.');
+    } else {
+        if (daemonRuntimePackages.length) notes.push(`Classified ${daemonRuntimePackages.length} package(s) as daemon-runtime (change → rebuild/redeploy + restart).`);
+        if (webOnlyPackages.length) notes.push(`Classified ${webOnlyPackages.length} web-* package(s) as web-only (change → web redeploy, no daemon restart).`);
+        notes.push('Heuristic only: confirm each package actually matches its bucket before saving.');
+    }
+
+    const nonRuntimeRootFilePatterns = [
+        '*.md',
+        'docs/**',
+        'LICENSE',
+        'LICENSE.*',
+        '.gitignore',
+    ];
+    notes.push('nonRuntimeRootFilePatterns lists root files that demonstrably cannot change daemon runtime behavior; extend with your repo markers.');
+
+    const suggestedConfig: ChangeImpactConfig = {
+        ...(daemonRuntimePackages.length ? { daemonRuntimePackages } : {}),
+        ...(webOnlyPackages.length ? { webOnlyPackages } : {}),
+        nonRuntimeRootFilePatterns,
+        impactTargets: {
+            daemon: { recommendedCommand: 'rebuild + redeploy the daemon, then restart it' },
+            web: { recommendedCommand: 'redeploy the web app (no daemon restart required)' },
+            none: { recommendedCommand: 'no action required' },
+        },
+    };
+
+    return {
+        suggestedConfig,
+        notes,
+        discoveredPackages: { daemon: daemonRuntimePackages, web: webOnlyPackages, unclassified },
+    };
+}