@bbigbang/core 0.1.0

package/dist/services/workspaceToolPromotion.js

@@ -0,0 +1,255 @@
+import { buildWorkspaceToolPanelActionParamKey, collectPanelLevelUnsupportedNodes, collectPanelTemplateUnsupportedNodes, mapPanelLevelNodes, panelLevelNodeContainsEmptyLayoutContainer, } from '@bbigbang/protocol';
+import { parseWorkspaceToolManifest, resolveWorkspaceToolActionParamBinding } from './workspaceToolManifest.js';
+import { buildToolActionParameterFormSectionForActions } from './workspaceToolPanelProjection.js';
+export function hasRowTemplateGridPromotionSeed(props) {
+    return isPlainRecord(props)
+        && Array.isArray(props.fields)
+        && isPlainRecord(props.template);
+}
+function resolveDirectPromotedPanelActionMode(action) {
+    if (action.mode)
+        return action.mode;
+    return action.command?.trim() || action.rpcCommand?.trim() ? 'platform_exec' : 'notify_agent';
+}
+const DIRECT_TOOL_PROMOTION_UNSUPPORTED_PANEL_LEVEL_NODE_TYPES = new Set([
+    'DatePicker',
+    'MultiSelect',
+    'TagInput',
+    'FileUpload',
+    'Button',
+]);
+const DIRECT_TOOL_PROMOTION_INTERACTIVE_PANEL_LEVEL_NODE_TYPES = new Set([
+    'TextInput',
+    'TextArea',
+    'NumberInput',
+    'Checkbox',
+    'Select',
+    'MultiSelect',
+    'TagInput',
+    'Slider',
+    'DatePicker',
+    'FileUpload',
+    'Button',
+    'ActionBar',
+]);
+const DIRECT_TOOL_PROMOTION_UNSUPPORTED_TEMPLATE_NODE_TYPES = new Set([
+    'FormField',
+    'SubmitButton',
+]);
+function panelLevelNodeRequiresAgentAssistedToolPromotion(node, options) {
+    if (!isPlainRecord(node) || typeof node.type !== 'string')
+        return false;
+    return collectPanelLevelUnsupportedNodes(node, {
+        unsupportedTypes: DIRECT_TOOL_PROMOTION_UNSUPPORTED_PANEL_LEVEL_NODE_TYPES,
+        interactiveTypes: DIRECT_TOOL_PROMOTION_INTERACTIVE_PANEL_LEVEL_NODE_TYPES,
+        allowInteractiveTypes: options?.allowToolParameterNodes === true,
+    }).length > 0;
+}
+function panelTemplateNodeRequiresAgentAssistedToolPromotion(node) {
+    if (!isPlainRecord(node) || typeof node.type !== 'string')
+        return false;
+    return collectPanelTemplateUnsupportedNodes(node, {
+        unsupportedTypes: DIRECT_TOOL_PROMOTION_UNSUPPORTED_TEMPLATE_NODE_TYPES,
+        predicate: (candidate) => ((candidate.type === 'ImageSlot' || candidate.type === 'MediaBlock')
+            && candidate.editable === true),
+    }).length > 0;
+}
+function panelPropsRequireAgentAssistedToolPromotion(props) {
+    return panelLevelNodeRequiresAgentAssistedToolPromotion(props.summary)
+        || panelTemplateNodeRequiresAgentAssistedToolPromotion(props.template);
+}
+function buildDirectPromotedParameterBindingIndex(actions) {
+    const index = new Map();
+    for (const action of actions) {
+        for (const field of action.paramsSchema ?? []) {
+            const existing = index.get(field.name);
+            if (existing && existing !== 'ambiguous') {
+                index.set(field.name, 'ambiguous');
+            }
+            else if (!existing) {
+                index.set(field.name, { actionId: action.actionId, field });
+            }
+        }
+    }
+    return index;
+}
+function translateDirectPromotedParameterForm(node, actions) {
+    if (!node)
+        return null;
+    const paramIndex = buildDirectPromotedParameterBindingIndex(actions);
+    const actionIds = new Set(actions.map((action) => action.actionId));
+    const actionsById = new Map(actions.map((action) => [action.actionId, action]));
+    return translateDirectPromotedParameterFormNode(node, actions, paramIndex, actionIds, actionsById);
+}
+function translateDirectPromotedParameterFormNode(node, actions, paramIndex, actionIds, actionsById) {
+    if (!isPlainRecord(node) || typeof node.type !== 'string')
+        return null;
+    if (panelLevelNodeContainsEmptyLayoutContainer(node))
+        return null;
+    let failed = false;
+    const translated = mapPanelLevelNodes(node, (candidate) => {
+        if (DIRECT_TOOL_PROMOTION_UNSUPPORTED_PANEL_LEVEL_NODE_TYPES.has(candidate.type)) {
+            failed = true;
+            return null;
+        }
+        switch (candidate.type) {
+            case 'ActionBar': {
+                if (Array.isArray(candidate.actionIds) && candidate.actionIds.some((actionId) => typeof actionId !== 'string' || !actionIds.has(actionId))) {
+                    failed = true;
+                    return null;
+                }
+                return undefined;
+            }
+            case 'TextInput':
+            case 'TextArea':
+            case 'NumberInput':
+            case 'Checkbox':
+            case 'Select':
+            case 'Slider': {
+                if (!isPlainRecord(candidate.props)) {
+                    failed = true;
+                    return null;
+                }
+                const translatedName = translateDirectPromotedParameterControlName(candidate.props.name, candidate.type, actions, paramIndex, actionsById);
+                if (!translatedName) {
+                    failed = true;
+                    return null;
+                }
+                return {
+                    ...candidate,
+                    props: {
+                        ...candidate.props,
+                        name: translatedName,
+                    },
+                };
+            }
+            default:
+                return undefined;
+        }
+    });
+    return failed ? null : translated;
+}
+function translateDirectPromotedParameterControlName(rawName, nodeType, actions, paramIndex, actionsById) {
+    if (typeof rawName !== 'string' || !rawName.trim())
+        return null;
+    const existingBinding = resolveWorkspaceToolActionParamBinding(actions, rawName);
+    if (existingBinding) {
+        const action = actionsById.get(existingBinding.actionId);
+        if (!action)
+            return null;
+        const field = (action.paramsSchema ?? []).find((candidate) => candidate.name === existingBinding.paramName);
+        if (!field)
+            return null;
+        if (!isToolParameterFormNodeTypeCompatible(nodeType, field.input ?? 'text'))
+            return null;
+        return buildWorkspaceToolPanelActionParamKey(existingBinding.actionId, existingBinding.paramName);
+    }
+    const binding = paramIndex.get(rawName);
+    if (!binding || binding === 'ambiguous')
+        return null;
+    if (!isToolParameterFormNodeTypeCompatible(nodeType, binding.field.input ?? 'text'))
+        return null;
+    return buildWorkspaceToolPanelActionParamKey(binding.actionId, binding.field.name);
+}
+function isToolParameterFormNodeTypeCompatible(nodeType, input) {
+    if (input === 'checkbox')
+        return nodeType === 'Checkbox';
+    if (input === 'number')
+        return nodeType === 'NumberInput' || nodeType === 'Slider';
+    if (input === 'select')
+        return nodeType === 'Select';
+    return nodeType === 'TextInput' || nodeType === 'TextArea';
+}
+export function buildDirectPromotedToolManifest(panel) {
+    if (panel.component !== 'RowTemplateGrid' || !hasRowTemplateGridPromotionSeed(panel.props))
+        return null;
+    const props = panel.props;
+    if (!props)
+        return null;
+    if (panelPropsRequireAgentAssistedToolPromotion(props))
+        return null;
+    const actionIds = new Set();
+    const actions = [];
+    let hasPlatformExecAction = false;
+    for (const action of panel.actions ?? []) {
+        if (!action.id?.trim() || !action.label?.trim() || actionIds.has(action.id))
+            return null;
+        actionIds.add(action.id);
+        const mode = resolveDirectPromotedPanelActionMode(action);
+        if (mode === 'platform_exec') {
+            const command = action.command?.trim() || action.rpcCommand?.trim() || '';
+            const toolKind = action.toolKind ?? (action.persistent === true ? 'start' : 'custom');
+            if (!command && toolKind !== 'stop')
+                return null;
+            const cwd = action.cwd?.trim() || action.rpcCwd?.trim() || '';
+            hasPlatformExecAction = true;
+            actions.push({
+                actionId: action.id,
+                label: action.label,
+                description: action.description,
+                kind: toolKind,
+                mode: 'platform_exec',
+                ...(command ? { command } : {}),
+                ...(cwd ? { cwd } : {}),
+                ...(typeof action.persistent === 'boolean' ? { persistent: action.persistent } : {}),
+                ...(typeof action.maxRunSeconds === 'number' ? { maxRunSeconds: action.maxRunSeconds } : {}),
+                ...(typeof action.idleTimeoutSeconds === 'number' ? { idleTimeoutSeconds: action.idleTimeoutSeconds } : {}),
+                ...(Array.isArray(action.paramsSchema) ? { paramsSchema: action.paramsSchema } : {}),
+            });
+            continue;
+        }
+        actions.push({
+            actionId: action.id,
+            label: action.label,
+            description: action.description,
+            kind: 'custom',
+            mode: 'notify_agent',
+        });
+    }
+    const translatedParameterForm = props.parameterForm
+        ? translateDirectPromotedParameterForm(props.parameterForm, actions)
+        : null;
+    if (props.parameterForm && !translatedParameterForm)
+        return null;
+    const fallbackParameterForm = translatedParameterForm
+        ?? buildToolActionParameterFormSectionForActions(actions);
+    const title = typeof props.title === 'string' && props.title.trim()
+        ? props.title.trim()
+        : 'Panel Tool';
+    const summary = isPlainRecord(panel.result) && typeof panel.result.summary === 'string'
+        ? panel.result.summary.trim()
+        : '';
+    const baseSlug = title
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_.-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 48);
+    const shortPanelId = panel.id.replace(/[^a-zA-Z0-9]/g, '').slice(0, 8).toLowerCase() || 'panel';
+    const manifest = {
+        slug: `${baseSlug || 'panel'}-${shortPanelId}`,
+        name: title,
+        description: summary || `Static tool promoted from panel ${panel.id}.`,
+        ...(hasPlatformExecAction ? { defaultCwd: '.' } : {}),
+        actions,
+        view: {
+            title,
+            fields: props.fields,
+            mediaSlots: Array.isArray(props.mediaSlots)
+                ? props.mediaSlots
+                : [],
+            ...(fallbackParameterForm ? { parameterForm: fallbackParameterForm } : {}),
+            template: props.template,
+        },
+    };
+    try {
+        parseWorkspaceToolManifest(JSON.stringify(manifest));
+    }
+    catch {
+        return null;
+    }
+    return manifest;
+}
+function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/services/workspaceToolPromotionState.js

@@ -0,0 +1,224 @@
+const CREATE_NEW_TOOL_UNAVAILABLE_MESSAGE = 'Workspace tools can only be created from a /tool conversation or a tool maintenance chat; ordinary surfaces may only republish an existing same-agent tool.';
+const DIFFERENT_LIVE_TOOL_SLUG_MESSAGE = 'A different tool already uses this slug. Rename the linked tool or pick another slug.';
+const TOOL_LINKED_TO_DIFFERENT_SOURCE_PANEL_MESSAGE = 'This tool is already linked to a different source panel.';
+const SOURCE_PANEL_LINKED_TO_DIFFERENT_LIVE_TOOL_MESSAGE = 'This panel is already linked to a different live tool.';
+export function isDeletedLinkedToolPromotionRetryable(promotion) {
+    return Boolean(promotion
+        && !promotion.toolId
+        && promotion.linkedToolId
+        && promotion.linkedToolDeletedAt
+        && promotion.updatedAt <= promotion.linkedToolDeletedAt);
+}
+export function resolveWorkspaceToolPromotionState(input) {
+    if (input.promotion?.toolId) {
+        const archived = Boolean(input.panelArchivedAt);
+        return {
+            state: archived ? 'source_archived_linked_live_tool' : 'linked_live_tool',
+            stateReason: archived
+                ? 'Source panel is archived after promotion; linked Workspace Tool is live.'
+                : 'Panel is linked to a live Workspace Tool.',
+            ctaLabel: 'Edit Tool',
+            disabledReason: null,
+            shouldOpenLinkedTool: true,
+            shouldCreateDirectTool: false,
+            shouldCreateAssistedPromotion: false,
+            shouldReturnPendingPromotion: false,
+            shouldRequeueDeletedPromotion: false,
+        };
+    }
+    if (isDeletedLinkedToolPromotionRetryable(input.promotion)) {
+        const retryUnavailableReason = input.retryUnavailableReason?.trim();
+        if (retryUnavailableReason) {
+            return {
+                state: 'ineligible',
+                stateReason: retryUnavailableReason,
+                ctaLabel: 'Retry Tool Upgrade',
+                disabledReason: retryUnavailableReason,
+                shouldOpenLinkedTool: false,
+                shouldCreateDirectTool: false,
+                shouldCreateAssistedPromotion: false,
+                shouldReturnPendingPromotion: false,
+                shouldRequeueDeletedPromotion: false,
+            };
+        }
+    }
+    if (isDeletedLinkedToolPromotionRetryable(input.promotion)) {
+        return {
+            state: 'linked_tool_deleted_retryable',
+            stateReason: 'The linked Workspace Tool was deleted; the promotion can be retried in the original conversation.',
+            ctaLabel: 'Retry Tool Upgrade',
+            disabledReason: null,
+            shouldOpenLinkedTool: false,
+            shouldCreateDirectTool: false,
+            shouldCreateAssistedPromotion: false,
+            shouldReturnPendingPromotion: false,
+            shouldRequeueDeletedPromotion: true,
+        };
+    }
+    if (input.promotion) {
+        return {
+            state: 'agent_assisted_pending',
+            stateReason: 'A Workspace Tool upgrade conversation already exists for this panel.',
+            ctaLabel: 'Continue Upgrade',
+            disabledReason: null,
+            shouldOpenLinkedTool: false,
+            shouldCreateDirectTool: false,
+            shouldCreateAssistedPromotion: false,
+            shouldReturnPendingPromotion: true,
+            shouldRequeueDeletedPromotion: false,
+        };
+    }
+    if (!input.eligible) {
+        const reason = input.ineligibleReason?.trim() || 'This panel cannot be upgraded to a tool.';
+        return {
+            state: 'ineligible',
+            stateReason: reason,
+            ctaLabel: null,
+            disabledReason: reason,
+            shouldOpenLinkedTool: false,
+            shouldCreateDirectTool: false,
+            shouldCreateAssistedPromotion: false,
+            shouldReturnPendingPromotion: false,
+            shouldRequeueDeletedPromotion: false,
+        };
+    }
+    if (input.directPromotable) {
+        return {
+            state: 'direct_promotable',
+            stateReason: 'Panel can be upgraded directly without an agent run.',
+            ctaLabel: 'Upgrade to Tool',
+            disabledReason: null,
+            shouldOpenLinkedTool: false,
+            shouldCreateDirectTool: true,
+            shouldCreateAssistedPromotion: false,
+            shouldReturnPendingPromotion: false,
+            shouldRequeueDeletedPromotion: false,
+        };
+    }
+    return {
+        state: 'eligible_unlinked',
+        stateReason: 'Panel can be upgraded through an agent-assisted Workspace Tool conversation.',
+        ctaLabel: 'Upgrade to Tool',
+        disabledReason: null,
+        shouldOpenLinkedTool: false,
+        shouldCreateDirectTool: false,
+        shouldCreateAssistedPromotion: true,
+        shouldReturnPendingPromotion: false,
+        shouldRequeueDeletedPromotion: false,
+    };
+}
+export function resolveWorkspaceToolPublishIdentityState(input) {
+    const linkedTool = input.linkedTool ?? null;
+    const existingByMaintenanceConversation = input.existingByMaintenanceConversation ?? null;
+    const existingByPanelId = input.existingByPanelId ?? null;
+    const existingBySlug = input.existingBySlug ?? null;
+    const existingByCollaboratorSlug = input.existingByCollaboratorSlug ?? null;
+    const liveExistingBySlug = existingBySlug && existingBySlug.deletedAt == null
+        ? existingBySlug
+        : null;
+    const existingIdentity = linkedTool
+        ?? existingByMaintenanceConversation
+        ?? existingByPanelId
+        ?? liveExistingBySlug
+        ?? existingByCollaboratorSlug
+        ?? null;
+    const existing = existingIdentity ?? liveExistingBySlug;
+    const restoredPanelId = linkedTool?.sourcePanelId
+        ?? existingByMaintenanceConversation?.sourcePanelId
+        ?? existingByPanelId?.sourcePanelId
+        ?? null;
+    const nextSourcePanelId = input.promotionLink?.panelId ?? restoredPanelId ?? null;
+    const queueToolId = input.promotionLink?.toolId
+        ?? linkedTool?.toolId
+        ?? existingByMaintenanceConversation?.toolId
+        ?? existingByPanelId?.toolId
+        ?? existingBySlug?.toolId
+        ?? existingByCollaboratorSlug?.toolId
+        ?? null;
+    const conflict = resolveWorkspaceToolPublishIdentityConflict({
+        allowCreateNewTool: input.allowCreateNewTool,
+        promotionLink: input.promotionLink,
+        existingIdentity,
+        existing,
+        existingBySlug: liveExistingBySlug,
+        existingByPanelId,
+    });
+    if (conflict) {
+        return {
+            state: 'blocked',
+            stateReason: conflict.message,
+            conflict,
+            existingIdentity,
+            existing,
+            restoredPanelId,
+            nextSourcePanelId,
+            queueToolId,
+            shouldCreateNewTool: false,
+            shouldUpdateExistingTool: false,
+        };
+    }
+    if (existingIdentity?.toolId) {
+        return {
+            state: 'update_existing_tool',
+            stateReason: 'Publish updates an existing Workspace Tool identity.',
+            conflict: null,
+            existingIdentity,
+            existing,
+            restoredPanelId,
+            nextSourcePanelId,
+            queueToolId,
+            shouldCreateNewTool: false,
+            shouldUpdateExistingTool: true,
+        };
+    }
+    return {
+        state: 'create_new_tool',
+        stateReason: 'Publish creates a new Workspace Tool identity.',
+        conflict: null,
+        existingIdentity,
+        existing,
+        restoredPanelId,
+        nextSourcePanelId,
+        queueToolId,
+        shouldCreateNewTool: true,
+        shouldUpdateExistingTool: false,
+    };
+}
+function resolveWorkspaceToolPublishIdentityConflict(params) {
+    if (!params.existingIdentity?.toolId && params.allowCreateNewTool === false) {
+        return {
+            kind: 'create_new_tool_unavailable',
+            message: CREATE_NEW_TOOL_UNAVAILABLE_MESSAGE,
+            statusCode: 409,
+        };
+    }
+    if (params.existingIdentity?.toolId
+        && params.existingBySlug?.toolId
+        && params.existingBySlug.toolId !== params.existingIdentity.toolId) {
+        return {
+            kind: 'different_live_tool_slug',
+            message: DIFFERENT_LIVE_TOOL_SLUG_MESSAGE,
+            statusCode: 409,
+        };
+    }
+    if (params.promotionLink?.panelId
+        && params.existing?.sourcePanelId
+        && params.existing.sourcePanelId !== params.promotionLink.panelId) {
+        return {
+            kind: 'tool_linked_to_different_source_panel',
+            message: TOOL_LINKED_TO_DIFFERENT_SOURCE_PANEL_MESSAGE,
+            statusCode: 409,
+        };
+    }
+    if (params.existingIdentity?.toolId
+        && params.existingByPanelId
+        && params.existingByPanelId.deletedAt == null
+        && params.existingByPanelId.toolId !== params.existingIdentity.toolId) {
+        return {
+            kind: 'source_panel_linked_to_different_live_tool',
+            message: SOURCE_PANEL_LINKED_TO_DIFFERENT_LIVE_TOOL_MESSAGE,
+            statusCode: 409,
+        };
+    }
+    return null;
+}

package/dist/services/workspaceToolPublishDiagnostics.js

@@ -0,0 +1,189 @@
+import { walkPanelLevelNodes, } from '@bbigbang/protocol';
+import { actionRequiresCommand, resolveWorkspaceToolActionMode } from './workspaceToolManifest.js';
+const SHELL_COMPLEXITY_PATTERNS = [
+    { code: 'heredoc', pattern: /<<[-~]?\s*['"]?[A-Za-z0-9_]+['"]?/, label: 'heredoc' },
+    { code: 'background_process', pattern: /(^|[;&|]\s*)(nohup|setsid)\b|\b(disown|daemonize)\b|--daemon\b|&\s*(?:$|[#;])/, label: 'background/daemon process control' },
+    { code: 'pid_file', pattern: /\b(pidfile|pid_file|PIDFILE)\b|\.pid\b|\bkill\s+-?\w*\s+/, label: 'PID file or kill management' },
+];
+export function buildWorkspaceToolPublishDiagnostics(manifest) {
+    const diagnostics = [];
+    const commandActions = manifest.actions.filter(isCommandPlatformAction);
+    const preferCliActionIds = new Set();
+    if (commandActions.length >= 3) {
+        for (const action of commandActions)
+            preferCliActionIds.add(action.actionId);
+    }
+    for (const action of commandActions) {
+        const command = action.command?.trim() ?? '';
+        const complexity = detectShellComplexity(command);
+        if (complexity) {
+            preferCliActionIds.add(action.actionId);
+            diagnostics.push({
+                severity: 'warning',
+                code: 'complex_command_shell',
+                message: `Action "${action.actionId}" uses ${complexity}; prefer moving shell orchestration into a bundle-local CLI wrapper.`,
+                actionIds: [action.actionId],
+            });
+        }
+    }
+    const persistentStartActions = manifest.actions.filter((action) => (resolveWorkspaceToolActionMode(action) === 'platform_exec'
+        && action.kind === 'start'
+        && action.persistent === true));
+    for (const action of persistentStartActions) {
+        if (!hasReliableStatusAction(manifest) || !hasStopAction(manifest)) {
+            if (isCommandPlatformAction(action)) {
+                preferCliActionIds.add(action.actionId);
+            }
+            diagnostics.push({
+                severity: 'warning',
+                code: 'persistent_lifecycle_incomplete',
+                message: `Persistent start action "${action.actionId}" should have reliable status and stop actions so the platform can explain and recover long-running processes.`,
+                actionIds: [action.actionId],
+            });
+        }
+    }
+    const repeatedEntryDiagnostics = buildRepeatedEntrypointDiagnostics(commandActions);
+    diagnostics.push(...repeatedEntryDiagnostics);
+    for (const diagnostic of repeatedEntryDiagnostics) {
+        for (const actionId of diagnostic.actionIds ?? [])
+            preferCliActionIds.add(actionId);
+    }
+    diagnostics.push(...buildAuthoringExperienceDiagnostics(manifest));
+    if (preferCliActionIds.size > 0) {
+        const actionIds = commandActions
+            .map((action) => action.actionId)
+            .filter((actionId) => preferCliActionIds.has(actionId));
+        diagnostics.unshift({
+            severity: 'warning',
+            code: 'prefer_cli_entry',
+            message: manifest.cli?.entry?.trim()
+                ? 'This manifest already declares cli.entry, but some actions still use direct commands. Prefer commandless actions for shared CLI-backed behavior.'
+                : 'This tool has a larger, complex, or repeated command-backed control surface. Prefer commandless actions backed by a bundle-local cli.entry wrapper so actions share one stable backend contract.',
+            actionIds,
+        });
+    }
+    return dedupeDiagnostics(diagnostics);
+}
+function buildAuthoringExperienceDiagnostics(manifest) {
+    const diagnostics = [];
+    const paramActions = manifest.actions.filter((action) => (action.paramsSchema?.length ?? 0) > 0);
+    const totalParams = paramActions.reduce((sum, action) => sum + (action.paramsSchema?.length ?? 0), 0);
+    if (!manifest.view.parameterForm && (paramActions.length >= 2 || totalParams >= 4)) {
+        diagnostics.push({
+            severity: 'warning',
+            code: 'explicit_parameter_form_recommended',
+            message: 'This tool has multiple action parameter groups or several parameters. Add view.parameterForm to control grouping, density, and action placement instead of relying on the generated single-column fallback.',
+            actionIds: paramActions.map((action) => action.actionId),
+        });
+    }
+    const runtimeActionIds = manifest.actions
+        .filter((action) => isRuntimeSummaryCandidate(manifest, action))
+        .map((action) => action.actionId);
+    if (runtimeActionIds.length > 0 && !summaryContainsRuntimeReadWidgets(manifest)) {
+        diagnostics.push({
+            severity: 'warning',
+            code: 'runtime_summary_widgets_recommended',
+            message: 'Long-running or persistent tools should add Tool-only RunStatusCard and RunLogViewer widgets in view.summary so users can see bounded run state and event tails without opening full run history.',
+            actionIds: runtimeActionIds,
+        });
+    }
+    return diagnostics;
+}
+function isRuntimeSummaryCandidate(manifest, action) {
+    if (manifest.runtime?.mode === 'persistent_runtime')
+        return true;
+    if (action.persistent === true)
+        return true;
+    if (typeof action.maxRunSeconds === 'number' && Number.isFinite(action.maxRunSeconds) && action.maxRunSeconds >= 60)
+        return true;
+    return false;
+}
+function summaryContainsRuntimeReadWidgets(manifest) {
+    let hasStatus = false;
+    let hasLog = false;
+    walkPanelLevelNodes(manifest.view.summary, (node) => {
+        if (node.type === 'RunStatusCard')
+            hasStatus = true;
+        if (node.type === 'RunLogViewer')
+            hasLog = true;
+        if (hasStatus && hasLog) {
+            return false;
+        }
+        return undefined;
+    });
+    return hasStatus && hasLog;
+}
+function isCommandPlatformAction(action) {
+    return resolveWorkspaceToolActionMode(action) === 'platform_exec'
+        && Boolean(action.command?.trim());
+}
+function detectShellComplexity(command) {
+    for (const { pattern, label } of SHELL_COMPLEXITY_PATTERNS) {
+        if (pattern.test(command))
+            return label;
+    }
+    const chainMatches = command.match(/&&|\|\||;/g) ?? [];
+    if (chainMatches.length >= 2)
+        return 'multi-step shell chaining';
+    if (command.length > 240)
+        return 'a long inline command';
+    return null;
+}
+function hasReliableStatusAction(manifest) {
+    return manifest.actions.some((action) => (resolveWorkspaceToolActionMode(action) === 'platform_exec'
+        && action.kind === 'status'
+        && (Boolean(action.command?.trim()) || Boolean(manifest.cli?.entry?.trim()))));
+}
+function hasStopAction(manifest) {
+    return manifest.actions.some((action) => (resolveWorkspaceToolActionMode(action) === 'platform_exec'
+        && action.kind === 'stop'
+        && (!actionRequiresCommand(action) || Boolean(action.command?.trim()) || Boolean(manifest.cli?.entry?.trim()))));
+}
+function buildRepeatedEntrypointDiagnostics(commandActions) {
+    const actionsByEntry = new Map();
+    for (const action of commandActions) {
+        const entry = extractScriptEntrypoint(action.command ?? '');
+        if (!entry)
+            continue;
+        const actions = actionsByEntry.get(entry) ?? [];
+        actions.push(action);
+        actionsByEntry.set(entry, actions);
+    }
+    const diagnostics = [];
+    for (const [entry, actions] of actionsByEntry) {
+        if (actions.length < 2)
+            continue;
+        diagnostics.push({
+            severity: 'warning',
+            code: 'repeated_entrypoint_commands',
+            message: `Multiple actions invoke "${entry}" directly. Prefer one cli.entry wrapper and commandless actions for shared backend behavior.`,
+            actionIds: actions.map((action) => action.actionId),
+        });
+    }
+    return diagnostics;
+}
+function extractScriptEntrypoint(command) {
+    const normalized = command.trim();
+    const interpreterMatch = normalized.match(/(?:^|[\s;&|])(?:python3?|node|tsx|bun)\s+(['"]?)([^'"\s]+)\1/);
+    if (interpreterMatch?.[2])
+        return stripShellRelativePrefix(interpreterMatch[2]);
+    const scriptMatch = normalized.match(/(?:^|[\s;&|])(['"]?)([^'"\s]+\.(?:py|js|mjs|cjs|ts))\1(?:\s|$)/);
+    if (scriptMatch?.[2])
+        return stripShellRelativePrefix(scriptMatch[2]);
+    return null;
+}
+function stripShellRelativePrefix(entry) {
+    return entry.replace(/^\.\//, '');
+}
+function dedupeDiagnostics(diagnostics) {
+    const seen = new Set();
+    const deduped = [];
+    for (const diagnostic of diagnostics) {
+        const key = `${diagnostic.code}:${(diagnostic.actionIds ?? []).join(',')}:${diagnostic.message}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(diagnostic);
+    }
+    return deduped;
+}