vibe-coding-master 0.7.47 → 0.7.49

package/dist/backend/services/role-context-restart-service.js

@@ -0,0 +1,240 @@
+import path from "node:path";
+import { VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { resolveRepoPath } from "../adapters/filesystem.js";
+import { toVcmError, VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const STATE_DIR = "restart-with-context";
+export function createRoleContextRestartService(deps) {
+    const pending = new Map();
+    const operations = new Map();
+    const now = deps.now ?? (() => new Date().toISOString());
+    return {
+        async restart(repoRoot, taskSlug, role, input = {}) {
+            return withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                const current = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
+                if (!current) {
+                    throw new VcmError({
+                        code: "SESSION_MISSING",
+                        message: `${role} session has not been started.`,
+                        statusCode: 404
+                    });
+                }
+                const state = {
+                    version: 1,
+                    taskSlug,
+                    role,
+                    sourceSessionId: current.id,
+                    status: "launching",
+                    permissionMode: input.permissionMode ?? current.permissionMode,
+                    model: input.model ?? current.model,
+                    effort: input.effort ?? current.effort,
+                    cols: input.cols,
+                    rows: input.rows,
+                    updatedAt: now()
+                };
+                await persist(repoRoot, state);
+                return launch(repoRoot, state);
+            });
+        },
+        async recoverTask(repoRoot, taskSlug) {
+            for (const role of VCM_ROLE_NAMES) {
+                await withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                    const state = await load(repoRoot, taskSlug, role);
+                    if (!state) {
+                        return;
+                    }
+                    const session = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
+                    if (state.replacementSessionId
+                        && session?.id === state.replacementSessionId
+                        && session.claudeSessionId) {
+                        await remove(repoRoot, state);
+                        return;
+                    }
+                    state.status = "launching";
+                    state.error = undefined;
+                    state.updatedAt = now();
+                    await persist(repoRoot, state);
+                    await launch(repoRoot, state);
+                });
+            }
+        },
+        async recordPromptSubmitted(repoRoot, taskSlug, role, sessionId) {
+            await withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                const state = pending.get(restartKey(repoRoot, taskSlug, role))
+                    ?? await load(repoRoot, taskSlug, role);
+                if (!state
+                    || state.status !== "awaiting_prompt_confirmation"
+                    || state.replacementSessionId !== sessionId) {
+                    return;
+                }
+                await remove(repoRoot, state);
+            });
+        },
+        async clearRole(repoRoot, taskSlug, role) {
+            await withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                pending.delete(restartKey(repoRoot, taskSlug, role));
+                const target = await statePath(repoRoot, taskSlug, role);
+                if (await deps.fs.pathExists(target)) {
+                    await deps.fs.removePath?.(target, { force: true });
+                }
+            });
+        },
+        async clear(repoRoot, taskSlug) {
+            for (const role of VCM_ROLE_NAMES) {
+                pending.delete(restartKey(repoRoot, taskSlug, role));
+            }
+            const target = await stateDirectory(repoRoot, taskSlug);
+            if (await deps.fs.pathExists(target)) {
+                await deps.fs.removePath?.(target, { recursive: true, force: true });
+            }
+        }
+    };
+    async function launch(repoRoot, state) {
+        const prompts = await buildPrompts(repoRoot, state.taskSlug, state.role);
+        try {
+            const replacement = await deps.sessionService.restartRoleSessionForContext(repoRoot, state.taskSlug, state.role, {
+                permissionMode: state.permissionMode,
+                model: state.model,
+                effort: state.effort,
+                cols: state.cols,
+                rows: state.rows,
+                appendSystemPrompt: prompts.system
+            });
+            state.replacementSessionId = replacement.id;
+            state.status = "awaiting_prompt_confirmation";
+            state.updatedAt = now();
+            await persist(repoRoot, state);
+            await deps.sessionService.submitRolePrompt(repoRoot, state.taskSlug, state.role, replacement.id, prompts.user);
+            return replacement;
+        }
+        catch (error) {
+            const normalized = toVcmError(error);
+            state.status = "blocked";
+            state.error = {
+                code: normalized.code,
+                message: normalized.message
+            };
+            state.updatedAt = now();
+            await persist(repoRoot, state);
+            throw error;
+        }
+    }
+    async function buildPrompts(repoRoot, taskSlug, role) {
+        const [config, task] = await Promise.all([
+            deps.projectService.loadConfig(repoRoot),
+            deps.taskService.loadTask(repoRoot, taskSlug)
+        ]);
+        const handoffDir = task.handoffDir;
+        const stateRoot = config.stateRoot;
+        const files = roleContextFiles(role, handoffDir, stateRoot);
+        return {
+            system: [
+                `This fresh ${role} session continues the current VCM task after Restart With Context.`,
+                "",
+                "Before continuing, read the existing files or directories that apply:",
+                ...files.map((file) => `- ${file}`),
+                "- the current worktree and Git state",
+                "",
+                "Treat the current artifacts and worktree as the source of truth. Continue the accepted assignment from the recorded current state. Do not repeat completed work or rely on the previous Session transcript."
+            ].join("\n"),
+            user: `[VCM RESTART WITH CONTEXT]\nRestore the current ${role} work from the listed task artifacts and continue the accepted assignment.`
+        };
+    }
+    async function persist(repoRoot, state) {
+        await deps.fs.writeJsonAtomic(await statePath(repoRoot, state.taskSlug, state.role), state);
+        pending.set(restartKey(repoRoot, state.taskSlug, state.role), state);
+    }
+    async function load(repoRoot, taskSlug, role) {
+        const target = await statePath(repoRoot, taskSlug, role);
+        if (!(await deps.fs.pathExists(target))) {
+            return undefined;
+        }
+        const state = await deps.fs.readJson(target);
+        if (state.version !== 1
+            || state.taskSlug !== taskSlug
+            || state.role !== role
+            || !["launching", "awaiting_prompt_confirmation", "blocked"].includes(state.status)) {
+            throw new VcmError({
+                code: "ROLE_CONTEXT_RESTART_STATE_INVALID",
+                message: `Restart With Context state is invalid for ${role} in task ${taskSlug}.`,
+                statusCode: 500
+            });
+        }
+        pending.set(restartKey(repoRoot, taskSlug, role), state);
+        return state;
+    }
+    async function remove(repoRoot, state) {
+        pending.delete(restartKey(repoRoot, state.taskSlug, state.role));
+        const target = await statePath(repoRoot, state.taskSlug, state.role);
+        if (await deps.fs.pathExists(target)) {
+            await deps.fs.removePath?.(target, { force: true });
+        }
+    }
+    async function stateDirectory(repoRoot, taskSlug) {
+        const [config, task] = await Promise.all([
+            deps.projectService.loadConfig(repoRoot),
+            deps.taskService.loadTask(repoRoot, taskSlug)
+        ]);
+        return resolveRepoPath(getTaskRuntimeRepoRoot(task), path.posix.join(config.stateRoot, STATE_DIR));
+    }
+    async function statePath(repoRoot, taskSlug, role) {
+        return path.join(await stateDirectory(repoRoot, taskSlug), `${role}.json`);
+    }
+    async function withLock(key, operation) {
+        const previous = operations.get(key) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(operation);
+        operations.set(key, current);
+        try {
+            return await current;
+        }
+        finally {
+            if (operations.get(key) === current) {
+                operations.delete(key);
+            }
+        }
+    }
+}
+function roleContextFiles(role, handoffDir, stateRoot) {
+    switch (role) {
+        case "project-manager":
+            return [
+                `${handoffDir}/workflow-progress.md`,
+                `${stateRoot}/workflow/state.json`,
+                `${stateRoot}/workflow-control.json`,
+                `${handoffDir}/messages/`
+            ];
+        case "architect":
+            return [
+                `${handoffDir}/role-commands/architect.md`,
+                `${handoffDir}/architecture-brief.md`,
+                `${handoffDir}/architecture-evidence.md`,
+                `${handoffDir}/planning-progress.md`,
+                `${handoffDir}/architecture-plan.md`,
+                `${handoffDir}/architect-debug.md`,
+                `${handoffDir}/architecture-diagnosis.md`,
+                ".ai/vcm/gate-reviews/index.json"
+            ];
+        case "coder":
+            return [
+                `${handoffDir}/role-commands/coder.md`,
+                `${handoffDir}/architecture-plan.md`,
+                `${handoffDir}/coder-completion.md`,
+                ".ai/vcm/coder-workers/"
+            ];
+        case "tester":
+            return [
+                `${handoffDir}/role-commands/tester.md`,
+                `${handoffDir}/architecture-plan.md`,
+                `${handoffDir}/coder-completion.md`,
+                `${handoffDir}/test-report.md`
+            ];
+        case "reviewer":
+            return [
+                ".ai/vcm/gate-reviews/index.json",
+                ".ai/vcm/gate-reviews/requests/"
+            ];
+    }
+}
+function restartKey(repoRoot, taskSlug, role) {
+    return `${repoRoot}\0${taskSlug}\0${role}`;
+}

package/dist/backend/services/runtime-recovery-service.js

@@ -35,6 +35,8 @@ export function createRuntimeRecoveryService(deps) {
                     await recoverMessages(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
                     await recoverGateReview(taskRepoRoot, recoveredAt, context);
                     await cleanupCoderWorkers(taskRepoRoot, context);
+                    await deps.architectRestartService?.recoverTask(repoRoot, task.taskSlug);
+                    await deps.roleContextRestartService?.recoverTask(repoRoot, task.taskSlug);
                     if ((roundRecovered || task.status === "running") && !hasLiveTaskSession(task.taskSlug)) {
                         await deps.taskService.updateTaskStatus(repoRoot, task.taskSlug, "stopped");
                     }

package/dist/backend/services/session-service.js

@@ -45,7 +45,7 @@ export function createSessionService(deps) {
             harnessOutdated: sessionRevision < currentRevision
         };
     }
-    async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode) {
+    async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode, options = {}) {
         const config = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
@@ -145,7 +145,7 @@ export function createSessionService(deps) {
         };
         deps.registry.upsert(record);
         await persistRoleSessionRecord(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, record);
-        if (role === "project-manager") {
+        if (role === "project-manager" && options.restoreProjectManagerContext !== false) {
             await restoreProjectManagerWorkflowContext(record, taskRepoRoot, config.stateRoot);
         }
         return withHarnessRevisionView(taskRepoRoot, record);
@@ -1110,6 +1110,43 @@ export function createSessionService(deps) {
             await clearPersistedRoleSessionRecord(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, taskSlug, role, now());
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
+        async restartRoleSessionForContext(repoRoot, taskSlug, role, input = {}) {
+            const existing = await this.getRoleSession(repoRoot, taskSlug, role);
+            if (!existing) {
+                return launchRoleSession(repoRoot, taskSlug, role, input, "fresh", {
+                    restoreProjectManagerContext: false
+                });
+            }
+            await getModelLaunchEnvironment(normalizeClaudeModel(input.model ?? existing.model));
+            if (deps.runtime.getSession(existing.id)) {
+                await deps.runtime.stop(existing.id);
+            }
+            deps.registry.remove(existing.id);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            await clearPersistedRoleSessionRecord(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, taskSlug, role, now());
+            return launchRoleSession(repoRoot, taskSlug, role, input, "fresh", {
+                restoreProjectManagerContext: false
+            });
+        },
+        async submitRolePrompt(repoRoot, taskSlug, role, expectedSessionId, prompt) {
+            const session = await this.getRoleSession(repoRoot, taskSlug, role);
+            if (!session || session.id !== expectedSessionId || session.status !== "running") {
+                throw new VcmError({
+                    code: "ROLE_SESSION_NOT_RUNNING",
+                    message: `${role} replacement session is not running.`,
+                    statusCode: 409
+                });
+            }
+            if ((await waitForSessionInputReady(session.id)) === "exited") {
+                throw new VcmError({
+                    code: "ROLE_SESSION_START_FAILED",
+                    message: `${role} replacement session exited before it could accept the recovery prompt.`,
+                    statusCode: 409
+                });
+            }
+            await submitTerminalInput(deps.runtime, session.id, prompt);
+        },
         async getRoleSession(repoRoot, taskSlug, role) {
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);

package/dist/backend/services/task-close-service.js

@@ -5,7 +5,12 @@ export function createTaskCloseService(deps) {
         async closeTask(repoRoot, taskSlug) {
             const task = await deps.taskService.markTaskCleaned(repoRoot, taskSlug);
             const warnings = [];
-            deps.architectRestartService?.clear(repoRoot, taskSlug);
+            if (deps.architectRestartService) {
+                await bestEffort("Unable to clear Architect restart state", () => deps.architectRestartService.clear(repoRoot, taskSlug), warnings);
+            }
+            if (deps.roleContextRestartService) {
+                await bestEffort("Unable to clear Restart With Context state", () => deps.roleContextRestartService.clear(repoRoot, taskSlug), warnings);
+            }
             await stopTaskRoleSessions(repoRoot, taskSlug, warnings);
             await bestEffort("Unable to stop task translation runtime", () => deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), taskSlug, { clearCache: true }), warnings);
             await bestEffort("Unable to clear task round runtime", () => deps.roundService.stopTask(taskSlug), warnings);

package/dist/backend/templates/harness/coder-agent.js

@@ -85,6 +85,7 @@ ${renderRoleMemoryRules("coder")}
 
 - In Docs-Only Flow, commit the documentation changes and submit \`.ai/vcm/handoffs/docs-update-report.md\` through \`vcm-artifact\` with the decision, changed and reviewed documents, evidence, checks, commit, and remaining documentation issues. Do not submit \`coder-completion.md\` for Docs-Only work.
 - Submit \`.ai/vcm/handoffs/coder-completion.md\` before routing back to project-manager: write a candidate outside \`.ai/vcm\`, then run \`.ai/tools/vcm-artifact coder-completion --file <candidate> --mode draft|final\`. This file is the complete, self-contained current implementation completion evidence, not a log. Each revision must restate every Scaffold Manifest disposition, changed file, helper, deviation, generated-context result, baseline-test change, L0/L1 command and result, worker result, commit, and objective failure still needed to review the current implementation without a prior revision. Replace stale content instead of appending history.
+- Maintain an incomplete \`coder-completion.md\` draft while implementation is in progress. Replace it after each completed module or worker result and after compile, L0, or L1 results so it always states completed work, remaining scaffold items, current validation, and current commits. The final submission replaces this draft.
 - After committing the actual implementation state and before submitting a final \`coder-completion.md\`, run \`.ai/tools/check-scaffold-ledger --mode completion --completion <candidate>\`; submit the candidate only after it passes. An incomplete draft does not use completion mode.
 - \`coder-completion.md\` must include \`Decision: ready_for_review | incomplete | failed\`.
 - \`coder-completion.md\` must report every Scaffold Manifest item disposition in the fixed Scaffold Completion table, plus changed files, private helpers added, manifest deviations as report-only facts, generated context status, baseline tests added or updated, L0/L1 commands and results, worker commits and integration status when workers were used, and compile/typecheck or L0/L1 failures.

package/dist/backend/templates/harness/gate-review.js

@@ -1,4 +1,15 @@
 import { renderRoleMemoryRules } from "./role-memory.js";
+import { GATE_ANALYSIS_FIELDS, GATE_ANALYSIS_HEADINGS } from "../../services/managed-artifact-validation.js";
+function renderGateAnalysisSections() {
+    return Object.keys(GATE_ANALYSIS_HEADINGS)
+        .map((gate) => [
+        `<!-- Include ${GATE_ANALYSIS_HEADINGS[gate]} only for ${gate} gate. -->`,
+        `## ${GATE_ANALYSIS_HEADINGS[gate]}`,
+        "",
+        ...GATE_ANALYSIS_FIELDS[gate].map((field) => `- ${field}:`)
+    ].join("\n"))
+        .join("\n\n");
+}
 export function renderReviewerAgentRules() {
     return `## Role
 
@@ -362,56 +373,7 @@ Summary: <one or two sentences>
 Use this findings structure:
 
 \`\`\`md
-<!-- Include Architecture Analysis only for architecture-plan gate. -->
-## Architecture Analysis
-
-- Evidence Read:
-- Architecture Brief Fit:
-- End-To-End Flow:
-- Scope Fit:
-- Code Reality:
-- Invalidated Assumptions:
-- Existing-Class Completeness:
-- Ownership:
-- Data Flow:
-- Lifecycle:
-- Invariants:
-- Boundaries And Public Surface:
-- Failure Model:
-- Coder Readiness:
-
-<!-- Include Validation Analysis only for validation-adequacy gate. -->
-## Validation Analysis
-
-- Evidence Read:
-- Changed Behavior And Risk:
-- Coverage Mapping:
-- Baseline Coverage:
-- L2 Integration Coverage:
-- L3 Trigger Assessment:
-- L3 End-To-End Coverage:
-- Boundary And Failure Coverage:
-- Public Contract Coverage:
-- Test Integrity:
-- Test Infrastructure:
-- Skips And Gaps:
-- User Approval And Gap Disposition:
-- Validation Readiness:
-
-<!-- Include Code Diff Analysis only for code-diff gate. -->
-## Code Diff Analysis
-
-- Commit Range And Sources:
-- Evidence Read:
-- Changed Files And Symbols:
-- Changed Behavior:
-- Source Evidence Fit:
-- Callers And Public Surface:
-- State Lifecycle And Failure Paths:
-- Coding Standards:
-- Baseline Test Integrity:
-- Generated Context And Durable Docs:
-- Code Readiness:
+${renderGateAnalysisSections()}
 
 ## Findings
 
@@ -430,54 +392,7 @@ Use this findings structure:
 If there are no findings, write:
 
 \`\`\`md
-<!-- Include Architecture Analysis only for architecture-plan gate. -->
-## Architecture Analysis
-
-- Evidence Read:
-- Architecture Brief Fit:
-- End-To-End Flow:
-- Scope Fit:
-- Code Reality:
-- Ownership:
-- Data Flow:
-- Lifecycle:
-- Invariants:
-- Boundaries And Public Surface:
-- Failure Model:
-- Coder Readiness:
-
-<!-- Include Validation Analysis only for validation-adequacy gate. -->
-## Validation Analysis
-
-- Evidence Read:
-- Changed Behavior And Risk:
-- Coverage Mapping:
-- Baseline Coverage:
-- L2 Integration Coverage:
-- L3 Trigger Assessment:
-- L3 End-To-End Coverage:
-- Boundary And Failure Coverage:
-- Public Contract Coverage:
-- Test Integrity:
-- Test Infrastructure:
-- Skips And Gaps:
-- User Approval And Gap Disposition:
-- Validation Readiness:
-
-<!-- Include Code Diff Analysis only for code-diff gate. -->
-## Code Diff Analysis
-
-- Commit Range And Sources:
-- Evidence Read:
-- Changed Files And Symbols:
-- Changed Behavior:
-- Source Evidence Fit:
-- Callers And Public Surface:
-- State Lifecycle And Failure Paths:
-- Coding Standards:
-- Baseline Test Integrity:
-- Generated Context And Durable Docs:
-- Code Readiness:
+${renderGateAnalysisSections()}
 
 ## Findings
 

package/dist/backend/templates/harness/tester-agent.js

@@ -151,6 +151,7 @@ Coverage Gap.
 ### Outputs
 
 - Write \`.ai/vcm/handoffs/test-report.md\` with \`Test Result: pass|fail|incomplete\`, evidence reviewed, tests added or updated, coverage mapping, validation progress, commands run or checked, validation results, test-infrastructure status and evidence, failed expectations, reproduction steps, skipped checks with reasons, coverage gaps, blocking validation issues, and user approval evidence.
+- Maintain an incomplete \`test-report.md\` draft while validation is in progress. Replace it after each completed validation level or long-running check and after changing tests or fixtures so it always states completed validation, remaining validation, current results, and current commits. The final submission replaces this draft.
 - \`test-report.md\` must include this test-infrastructure section:
 
 \`\`\`md

package/dist/backend/templates/harness/vcm-report-harness-issue-skill.js

@@ -38,7 +38,7 @@ Use this structure:
 - Evidence: <file paths, command names, logs, or repeated failure pattern>
 - Suspected harness area: <skill, role definition, tool, routing, validation, bootstrap, or managed instruction>
 - Impact: <who is affected and how>
-- Urgency: low | medium | high
+- Urgency: low|medium|high
 \`\`\`
 
 ## Constraints

package/dist/shared/validation/artifact-registry.js

@@ -214,7 +214,62 @@ export const ARTIFACT_DEFINITIONS = [
         ]
     }
 ];
+export const DYNAMIC_ARTIFACT_DEFINITIONS = [
+    {
+        kind: "route-message",
+        storage: "dynamic",
+        owner: ["project-manager", "architect", "coder", "tester"],
+        requiredHeadings: [],
+        allowedModes: ["final"]
+    },
+    {
+        kind: "coder-worker-report",
+        storage: "dynamic",
+        owner: "coder",
+        requiredHeadings: [
+            "Assigned Scope",
+            "Item Dispositions",
+            "Files Changed",
+            "Tests Added Or Updated",
+            "L0/L1 Checks",
+            "Commit",
+            "Skipped Assigned Checks",
+            "Objective Failures"
+        ],
+        allowedModes: ["final"]
+    },
+    {
+        kind: "gate-review-report",
+        storage: "dynamic",
+        owner: "reviewer",
+        requiredHeadings: ["Findings"],
+        allowedModes: ["final"]
+    },
+    {
+        kind: "memory-proposal",
+        storage: "dynamic",
+        owner: ["project-manager", "architect", "coder", "tester", "reviewer"],
+        requiredHeadings: ["Add", "Update", "Remove"],
+        allowedModes: ["final"]
+    },
+    {
+        kind: "harness-feedback",
+        storage: "dynamic",
+        owner: ["project-manager", "architect", "coder", "tester", "reviewer"],
+        requiredHeadings: [],
+        allowedModes: ["final"]
+    }
+];
+export const MANAGED_ARTIFACT_DEFINITIONS = [
+    ...ARTIFACT_DEFINITIONS.map((definition) => ({
+        ...definition,
+        storage: "handoff",
+        allowedModes: definition.kind === "workflow-progress" ? ["final"] : ["draft", "final"]
+    })),
+    ...DYNAMIC_ARTIFACT_DEFINITIONS
+];
 const DEFINITION_BY_KIND = new Map(ARTIFACT_DEFINITIONS.map((definition) => [definition.kind, definition]));
+const MANAGED_DEFINITION_BY_KIND = new Map(MANAGED_ARTIFACT_DEFINITIONS.map((definition) => [definition.kind, definition]));
 export function getArtifactDefinition(kind) {
     const definition = DEFINITION_BY_KIND.get(kind);
     if (!definition) {
@@ -225,3 +280,16 @@ export function getArtifactDefinition(kind) {
 export function isArtifactKind(value) {
     return DEFINITION_BY_KIND.has(value);
 }
+export function getManagedArtifactDefinition(kind) {
+    const definition = MANAGED_DEFINITION_BY_KIND.get(kind);
+    if (!definition) {
+        throw new Error(`Unknown managed artifact kind: ${kind}`);
+    }
+    return definition;
+}
+export function isDynamicArtifactKind(value) {
+    return DYNAMIC_ARTIFACT_DEFINITIONS.some((definition) => definition.kind === value);
+}
+export function isManagedArtifactKind(value) {
+    return MANAGED_DEFINITION_BY_KIND.has(value);
+}