@open-agent-toolkit/control-plane 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas Stang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,60 @@
+# @open-agent-toolkit/control-plane
+
+Read-only OAT control-plane library for parsing project artifacts into structured state.
+
+## Purpose
+
+`@open-agent-toolkit/control-plane` is the typed "read" layer behind OAT project inspection.
+
+It is responsible for:
+
+- parsing OAT project artifacts from disk
+- aggregating task progress, artifact status, and review state
+- recommending the next workflow skill from parsed project state
+- returning stable typed objects for CLI and future UI consumers
+
+The package is intentionally pure and read-only. It has no CLI, UI, or server dependencies beyond Node.js filesystem/path builtins and `yaml` for frontmatter parsing.
+
+## Public API
+
+```ts
+import {
+  getProjectState,
+  listProjects,
+  recommendSkill,
+} from '@open-agent-toolkit/control-plane';
+```
+
+### `getProjectState(projectPath)`
+
+Reads one OAT project directory and returns a full `ProjectState` snapshot, including:
+
+- phase and lifecycle status
+- task progress and current task
+- artifact and review status
+- blocker and HiLL metadata
+- PR/docs timestamps and recommendation output
+
+### `listProjects(projectsRoot)`
+
+Reads all projects under a configured projects root and returns lightweight `ProjectSummary` records suitable for list or dashboard surfaces.
+
+### `recommendSkill(projectState)`
+
+Pure function that maps parsed project state to the next recommended OAT workflow skill.
+
+## Current Consumers
+
+- `packages/cli/src/commands/project/status.ts`
+- `packages/cli/src/commands/project/list.ts`
+
+The CLI also uses adjacent config-resolution code for `oat config dump`, but the control plane remains focused on project artifact parsing rather than config ownership.
+
+## Development
+
+```bash
+pnpm --filter @open-agent-toolkit/control-plane test
+pnpm --filter @open-agent-toolkit/control-plane lint
+pnpm --filter @open-agent-toolkit/control-plane type-check
+pnpm --filter @open-agent-toolkit/control-plane build
+```

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export { getProjectState, listProjects } from './project.js';
+export { recommendSkill } from './recommender/router.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export { getProjectState, listProjects } from './project.js';
+export { recommendSkill } from './recommender/router.js';

package/dist/project.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectState, ProjectSummary } from './types.js';
+export declare function getProjectState(projectPath: string): Promise<ProjectState>;
+export declare function listProjects(projectsRoot: string): Promise<ProjectSummary[]>;
+//# sourceMappingURL=project.d.ts.map

package/dist/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAC;AAE1E,wBAAsB,eAAe,CACnC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,YAAY,CAAC,CA0DvB;AAED,wBAAsB,YAAY,CAChC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,cAAc,EAAE,CAAC,CA+E3B"}

package/dist/project.js

@@ -0,0 +1,191 @@
+import { access, readFile, readdir } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, relative } from 'node:path';
+import { recommendSkill } from './recommender/router.js';
+import { scanArtifacts } from './state/artifacts.js';
+import { parseStateFrontmatter } from './state/parser.js';
+import { parseReviewTable, scanUnprocessedReviews } from './state/reviews.js';
+import { parseTaskProgress } from './state/tasks.js';
+export async function getProjectState(projectPath) {
+    const displayPath = await resolveProjectDisplayPath(projectPath);
+    const [stateContent, planContent, implementationContent, artifacts, reviewFiles,] = await Promise.all([
+        readOptionalFile(join(projectPath, 'state.md')),
+        readOptionalFile(join(projectPath, 'plan.md')),
+        readOptionalFile(join(projectPath, 'implementation.md')),
+        scanArtifacts(projectPath),
+        scanUnprocessedReviews(projectPath),
+    ]);
+    const parsedState = parseStateFrontmatter(stateContent);
+    const reviews = mergeReviews(parseReviewTable(planContent), reviewFiles, projectPath);
+    const progress = parseTaskProgress(planContent, implementationContent);
+    const projectStateWithoutRecommendation = {
+        name: basename(projectPath),
+        path: displayPath,
+        phase: parsedState.phase ?? 'discovery',
+        phaseStatus: parsedState.phaseStatus ?? 'in_progress',
+        workflowMode: parsedState.workflowMode ?? 'spec-driven',
+        executionMode: parsedState.executionMode,
+        lifecycle: parsedState.lifecycle ?? 'active',
+        pauseTimestamp: parsedState.pauseTimestamp,
+        pauseReason: parsedState.pauseReason,
+        progress,
+        artifacts,
+        reviews,
+        blockers: parsedState.blockers,
+        hillCheckpoints: parsedState.hillCheckpoints,
+        hillCompleted: parsedState.hillCompleted,
+        prStatus: parsedState.prStatus,
+        prUrl: parsedState.prUrl,
+        docsUpdated: parsedState.docsUpdated,
+        lastCommit: parsedState.lastCommit,
+        timestamps: {
+            created: parsedState.projectCreated ?? '',
+            completed: parsedState.projectCompleted,
+            stateUpdated: parsedState.projectStateUpdated ?? '',
+        },
+    };
+    return {
+        ...projectStateWithoutRecommendation,
+        recommendation: recommendSkill(projectStateWithoutRecommendation),
+    };
+}
+export async function listProjects(projectsRoot) {
+    const repoRoot = await findRepoRoot(projectsRoot);
+    const entries = await readdir(projectsRoot, { withFileTypes: true });
+    const projectDirs = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => join(projectsRoot, entry.name));
+    const summaries = await Promise.all(projectDirs.map(async (projectDir) => {
+        const statePath = join(projectDir, 'state.md');
+        const planPath = join(projectDir, 'plan.md');
+        const implementationPath = join(projectDir, 'implementation.md');
+        const stateContent = await readOptionalFile(statePath);
+        if (!stateContent) {
+            return null;
+        }
+        const [planContent, implementationContent, artifacts, reviewFiles] = await Promise.all([
+            readOptionalFile(planPath),
+            readOptionalFile(implementationPath),
+            scanArtifacts(projectDir),
+            scanUnprocessedReviews(projectDir),
+        ]);
+        const parsedState = parseStateFrontmatter(stateContent);
+        const reviews = mergeReviews(parseReviewTable(planContent), reviewFiles, projectDir);
+        const progress = parseTaskProgress(planContent, implementationContent);
+        const stateWithoutRecommendation = {
+            name: basename(projectDir),
+            path: formatProjectDisplayPath(projectDir, repoRoot),
+            phase: parsedState.phase ?? 'discovery',
+            phaseStatus: parsedState.phaseStatus ?? 'in_progress',
+            workflowMode: parsedState.workflowMode ?? 'spec-driven',
+            executionMode: parsedState.executionMode,
+            lifecycle: parsedState.lifecycle ?? 'active',
+            pauseTimestamp: parsedState.pauseTimestamp,
+            pauseReason: parsedState.pauseReason,
+            progress,
+            artifacts,
+            reviews,
+            blockers: parsedState.blockers,
+            hillCheckpoints: parsedState.hillCheckpoints,
+            hillCompleted: parsedState.hillCompleted,
+            prStatus: parsedState.prStatus,
+            prUrl: parsedState.prUrl,
+            docsUpdated: parsedState.docsUpdated,
+            lastCommit: parsedState.lastCommit,
+            timestamps: {
+                created: parsedState.projectCreated ?? '',
+                completed: parsedState.projectCompleted,
+                stateUpdated: parsedState.projectStateUpdated ?? '',
+            },
+        };
+        return {
+            name: stateWithoutRecommendation.name,
+            path: stateWithoutRecommendation.path,
+            phase: stateWithoutRecommendation.phase,
+            phaseStatus: stateWithoutRecommendation.phaseStatus,
+            workflowMode: stateWithoutRecommendation.workflowMode,
+            lifecycle: stateWithoutRecommendation.lifecycle,
+            progress: {
+                completed: stateWithoutRecommendation.progress.completed,
+                total: stateWithoutRecommendation.progress.total,
+            },
+            recommendation: recommendSkill(stateWithoutRecommendation),
+        };
+    }));
+    return summaries
+        .filter((summary) => summary !== null)
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+async function resolveProjectDisplayPath(projectPath) {
+    if (!isAbsolute(projectPath)) {
+        return normalizePath(projectPath);
+    }
+    const repoRoot = await findRepoRoot(projectPath);
+    return formatProjectDisplayPath(projectPath, repoRoot);
+}
+function formatProjectDisplayPath(projectPath, repoRoot) {
+    if (!isAbsolute(projectPath)) {
+        return normalizePath(projectPath);
+    }
+    if (!repoRoot) {
+        return projectPath;
+    }
+    return normalizePath(relative(repoRoot, projectPath));
+}
+async function findRepoRoot(startPath) {
+    let currentPath = startPath;
+    while (true) {
+        if ((await pathExists(join(currentPath, '.git'))) ||
+            (await pathExists(join(currentPath, '.oat', 'config.json')))) {
+            return currentPath;
+        }
+        const parentPath = dirname(currentPath);
+        if (parentPath === currentPath) {
+            return null;
+        }
+        currentPath = parentPath;
+    }
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizePath(path) {
+    return path.replace(/\\/g, '/');
+}
+async function readOptionalFile(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return '';
+        }
+        throw error;
+    }
+}
+function mergeReviews(tableReviews, reviewFiles, projectPath) {
+    const merged = [...tableReviews];
+    const existingArtifacts = new Set(tableReviews.map((review) => review.artifact));
+    for (const reviewFile of reviewFiles) {
+        const relativeArtifact = relative(projectPath, reviewFile).replace(/\\/g, '/');
+        if (existingArtifacts.has(relativeArtifact)) {
+            continue;
+        }
+        merged.push({
+            scope: basename(reviewFile, '.md'),
+            type: 'code',
+            status: 'received',
+            date: '-',
+            artifact: relativeArtifact,
+        });
+    }
+    return merged;
+}

package/dist/recommender/boundary.d.ts

@@ -0,0 +1,3 @@
+import type { BoundaryTier } from '../types.js';
+export declare function detectBoundaryTier(frontmatter: Record<string, unknown>, content: string): BoundaryTier;
+//# sourceMappingURL=boundary.d.ts.map

package/dist/recommender/boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../src/recommender/boundary.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAQ7C,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,OAAO,EAAE,MAAM,GACd,YAAY,CAiBd"}

package/dist/recommender/boundary.js

@@ -0,0 +1,22 @@
+import { normalizeNullableString, parseBoolean, } from '../shared/utils/normalize.js';
+const TEMPLATE_PATTERNS = [
+    /\{Project Name\}/,
+    /\{Copy of/,
+    /\{Clear description/,
+];
+export function detectBoundaryTier(frontmatter, content) {
+    const status = normalizeNullableString(frontmatter.oat_status);
+    const isTemplate = parseBoolean(frontmatter.oat_template);
+    if (status === 'complete') {
+        return 1;
+    }
+    if (status === 'in_progress' &&
+        !isTemplate &&
+        !hasTemplatePlaceholders(content)) {
+        return 2;
+    }
+    return 3;
+}
+function hasTemplatePlaceholders(content) {
+    return TEMPLATE_PATTERNS.some((pattern) => pattern.test(content));
+}

package/dist/recommender/router.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectState, SkillRecommendation } from '../types.js';
+export declare function recommendSkill(state: Omit<ProjectState, 'recommendation'>): SkillRecommendation;
+//# sourceMappingURL=router.d.ts.map

package/dist/recommender/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/recommender/router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,YAAY,EAEZ,mBAAmB,EAEpB,MAAM,UAAU,CAAC;AAiElB,wBAAgB,cAAc,CAC5B,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,gBAAgB,CAAC,GAC1C,mBAAmB,CA8BrB"}

package/dist/recommender/router.js

@@ -0,0 +1,182 @@
+const CURRENT_PHASE_SKILLS = {
+    discovery: 'oat-project-discover',
+    spec: 'oat-project-spec',
+    design: 'oat-project-design',
+    plan: 'oat-project-plan',
+};
+const CURRENT_ARTIFACT_BY_PHASE = {
+    discovery: 'discovery',
+    spec: 'spec',
+    design: 'design',
+    plan: 'plan',
+    implement: 'implementation',
+};
+const SPEC_DRIVEN_ROUTES = {
+    'discovery:in_progress:3': 'oat-project-discover',
+    'discovery:in_progress:2': 'oat-project-spec',
+    'discovery:complete:1': 'oat-project-spec',
+    'spec:in_progress:3': 'oat-project-spec',
+    'spec:in_progress:2': 'oat-project-design',
+    'spec:complete:1': 'oat-project-design',
+    'design:in_progress:3': 'oat-project-design',
+    'design:in_progress:2': 'oat-project-plan',
+    'design:complete:1': 'oat-project-plan',
+    'plan:in_progress:3': 'oat-project-plan',
+    'plan:in_progress:2': 'oat-project-implement',
+    'plan:complete:1': 'oat-project-implement',
+    'implement:in_progress:any': 'oat-project-implement',
+};
+const QUICK_ROUTES = {
+    'discovery:in_progress:3': 'oat-project-discover',
+    'discovery:in_progress:2': 'oat-project-plan',
+    'discovery:complete:1': 'oat-project-plan',
+    'plan:in_progress:3': 'oat-project-plan',
+    'plan:in_progress:2': 'oat-project-implement',
+    'plan:complete:1': 'oat-project-implement',
+    'implement:in_progress:any': 'oat-project-implement',
+};
+const IMPORT_ROUTES = {
+    'plan:in_progress:3': 'oat-project-import-plan',
+    'plan:in_progress:2': 'oat-project-implement',
+    'plan:complete:1': 'oat-project-implement',
+    'implement:in_progress:any': 'oat-project-implement',
+};
+export function recommendSkill(state) {
+    const hillOverride = getHillOverride(state);
+    if (hillOverride) {
+        return hillOverride;
+    }
+    if (state.phase === 'implement' &&
+        (state.phaseStatus === 'complete' || state.phaseStatus === 'pr_open')) {
+        return getPostImplementationRecommendation(state);
+    }
+    const currentArtifact = getCurrentArtifact(state);
+    if (currentArtifact?.readyFor && currentArtifact.status === 'complete') {
+        return {
+            skill: normalizeImplementationSkill(currentArtifact.readyFor, state),
+            reason: 'Current artifact is complete and explicitly points to the next skill',
+        };
+    }
+    const earlyRoute = getEarlyPhaseRoute(state, currentArtifact?.boundaryTier ?? 3);
+    return {
+        skill: normalizeImplementationSkill(earlyRoute, state),
+        reason: `Route ${state.workflowMode} ${state.phase} work based on boundary tier`,
+    };
+}
+function getHillOverride(state) {
+    if (state.phase === 'implement') {
+        return null;
+    }
+    if (state.hillCheckpoints.includes(state.phase) &&
+        !state.hillCompleted.includes(state.phase)) {
+        return {
+            skill: CURRENT_PHASE_SKILLS[state.phase],
+            reason: 'HiLL gate is pending for the current phase',
+        };
+    }
+    return null;
+}
+function getPostImplementationRecommendation(state) {
+    if (hasIncompleteRevisionPhase(state)) {
+        return {
+            skill: normalizeImplementationSkill('oat-project-implement', state),
+            reason: 'Revision work remains incomplete',
+        };
+    }
+    if (hasUnprocessedReviewFeedback(state)) {
+        return {
+            skill: 'oat-project-review-receive',
+            reason: 'Unprocessed review feedback exists',
+        };
+    }
+    const finalReview = state.reviews.find((review) => review.scope === 'final' && review.type === 'code');
+    if (!finalReview || finalReview.status === 'pending') {
+        return {
+            skill: 'oat-project-review-provide',
+            reason: 'Final code review is required',
+            context: 'code final',
+        };
+    }
+    if (finalReview.status === 'fixes_completed') {
+        return {
+            skill: 'oat-project-review-provide',
+            reason: 'Review fixes are complete and need re-review',
+            context: 'code final',
+        };
+    }
+    if (finalReview.status !== 'passed') {
+        return {
+            skill: 'oat-project-review-receive',
+            reason: 'Final review findings still need processing',
+        };
+    }
+    const summaryArtifact = state.artifacts.find((artifact) => artifact.type === 'summary');
+    if (!summaryArtifact || summaryArtifact.status !== 'complete') {
+        return {
+            skill: 'oat-project-summary',
+            reason: 'Final review passed but summary is not complete',
+        };
+    }
+    if (state.phaseStatus !== 'pr_open') {
+        return {
+            skill: 'oat-project-pr-final',
+            reason: 'Summary is complete and the final PR has not been opened',
+        };
+    }
+    return {
+        skill: 'oat-project-complete',
+        reason: 'PR is open and the project is ready for completion',
+    };
+}
+function hasIncompleteRevisionPhase(state) {
+    return state.progress.phases.some((phase) => phase.isRevision && phase.completed < phase.total);
+}
+function hasUnprocessedReviewFeedback(state) {
+    return state.reviews.some((review) => {
+        if (review.scope === 'final' && review.type === 'code') {
+            return false;
+        }
+        return !isProcessedReviewStatus(review);
+    });
+}
+function isProcessedReviewStatus(review) {
+    return (review.status === 'passed' ||
+        review.status === 'fixes_added' ||
+        review.status === 'fixes_completed');
+}
+function getCurrentArtifact(state) {
+    return state.artifacts.find((artifact) => artifact.type === CURRENT_ARTIFACT_BY_PHASE[state.phase]);
+}
+function getEarlyPhaseRoute(state, boundaryTier) {
+    if (state.phase === 'implement' && state.phaseStatus === 'in_progress') {
+        return normalizeImplementationSkill('oat-project-implement', state);
+    }
+    const routes = getWorkflowRoutes(state.workflowMode);
+    const key = `${state.phase}:${state.phaseStatus}:${boundaryTier}`;
+    const route = routes[key];
+    if (route) {
+        return route;
+    }
+    if (state.phase === 'implement') {
+        return 'oat-project-implement';
+    }
+    return CURRENT_PHASE_SKILLS[state.phase];
+}
+function getWorkflowRoutes(workflowMode) {
+    switch (workflowMode) {
+        case 'quick':
+            return QUICK_ROUTES;
+        case 'import':
+            return IMPORT_ROUTES;
+        case 'spec-driven':
+        default:
+            return SPEC_DRIVEN_ROUTES;
+    }
+}
+function normalizeImplementationSkill(skill, state) {
+    if (skill === 'oat-project-implement' &&
+        state.executionMode === 'subagent-driven') {
+        return 'oat-project-subagent-implement';
+    }
+    return skill;
+}

package/dist/shared/utils/errors.d.ts

@@ -0,0 +1,2 @@
+export declare function isMissingFileError(error: unknown): boolean;
+//# sourceMappingURL=errors.d.ts.map

package/dist/shared/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/shared/utils/errors.ts"],"names":[],"mappings":"AAAA,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAO1D"}

package/dist/shared/utils/errors.js

@@ -0,0 +1,6 @@
+export function isMissingFileError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}

package/dist/shared/utils/frontmatter.d.ts

@@ -0,0 +1,3 @@
+export declare function extractFrontmatter(content: string): string | null;
+export declare function parseFrontmatterRecord(content: string): Record<string, unknown>;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/shared/utils/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../../src/shared/utils/frontmatter.ts"],"names":[],"mappings":"AAIA,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGjE;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAYzB"}

package/dist/shared/utils/frontmatter.js

@@ -0,0 +1,22 @@
+import YAML from 'yaml';
+const FRONTMATTER_PATTERN = /^---\s*\n([\s\S]*?)\n---\s*(?:\n|$)/;
+export function extractFrontmatter(content) {
+    const match = content.match(FRONTMATTER_PATTERN);
+    return match?.[1] ?? null;
+}
+export function parseFrontmatterRecord(content) {
+    const frontmatter = extractFrontmatter(content);
+    if (frontmatter == null) {
+        return {};
+    }
+    try {
+        const parsed = YAML.parse(frontmatter);
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/shared/utils/normalize.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeNullableString(value: unknown, options?: {
+    treatPlaceholdersAsNull?: boolean;
+}): string | null;
+export declare function parseBoolean(value: unknown): boolean;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/shared/utils/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/shared/utils/normalize.ts"],"names":[],"mappings":"AAEA,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE;IAAE,uBAAuB,CAAC,EAAE,OAAO,CAAA;CAAO,GAClD,MAAM,GAAG,IAAI,CAgBf;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAiBpD"}

package/dist/shared/utils/normalize.js

@@ -0,0 +1,29 @@
+const PLACEHOLDER_PATTERN = /^\{[^}]+\}$/;
+export function normalizeNullableString(value, options = {}) {
+    if (typeof value !== 'string') {
+        return value == null ? null : String(value);
+    }
+    const normalized = value.trim();
+    if (!normalized ||
+        normalized === 'null' ||
+        (options.treatPlaceholdersAsNull === true &&
+            PLACEHOLDER_PATTERN.test(normalized))) {
+        return null;
+    }
+    return normalized;
+}
+export function parseBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'true') {
+            return true;
+        }
+        if (normalized === 'false') {
+            return false;
+        }
+    }
+    return false;
+}

package/dist/state/artifacts.d.ts

@@ -0,0 +1,3 @@
+import type { ArtifactStatus } from '../types.js';
+export declare function scanArtifacts(projectPath: string): Promise<ArtifactStatus[]>;
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/state/artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../src/state/artifacts.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,UAAU,CAAC;AAW7D,wBAAsB,aAAa,CACjC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,cAAc,EAAE,CAAC,CA8B3B"}

package/dist/state/artifacts.js

@@ -0,0 +1,52 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { detectBoundaryTier } from '../recommender/boundary.js';
+import { isMissingFileError } from '../shared/utils/errors.js';
+import { parseFrontmatterRecord } from '../shared/utils/frontmatter.js';
+import { normalizeNullableString, parseBoolean, } from '../shared/utils/normalize.js';
+const ARTIFACT_TYPES = [
+    'discovery',
+    'spec',
+    'design',
+    'plan',
+    'implementation',
+    'summary',
+];
+export async function scanArtifacts(projectPath) {
+    return Promise.all(ARTIFACT_TYPES.map(async (type) => {
+        const path = join(projectPath, `${type}.md`);
+        const content = await tryReadFile(path);
+        if (content == null) {
+            return {
+                type,
+                exists: false,
+                path,
+                status: null,
+                readyFor: null,
+                isTemplate: false,
+                boundaryTier: 3,
+            };
+        }
+        const frontmatter = parseFrontmatterRecord(content);
+        return {
+            type,
+            exists: true,
+            path,
+            status: normalizeNullableString(frontmatter.oat_status),
+            readyFor: normalizeNullableString(frontmatter.oat_ready_for),
+            isTemplate: parseBoolean(frontmatter.oat_template),
+            boundaryTier: detectBoundaryTier(frontmatter, content),
+        };
+    }));
+}
+async function tryReadFile(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}

package/dist/state/parser.d.ts

@@ -0,0 +1,27 @@
+import type { ExecutionMode, Lifecycle, Phase, PhaseStatus, WorkflowMode } from '../types.js';
+export interface ParsedStateFrontmatter {
+    currentTask: string | null;
+    lastCommit: string | null;
+    blockers: string[];
+    hillCheckpoints: string[];
+    hillCompleted: string[];
+    parallelExecution: boolean;
+    phase: Phase | null;
+    phaseStatus: PhaseStatus | null;
+    executionMode: ExecutionMode;
+    lifecycle: Lifecycle | null;
+    pauseTimestamp: string | null;
+    pauseReason: string | null;
+    workflowMode: WorkflowMode | null;
+    workflowOrigin: string | null;
+    docsUpdated: string | null;
+    prStatus: string | null;
+    prUrl: string | null;
+    projectCreated: string | null;
+    projectCompleted: string | null;
+    projectStateUpdated: string | null;
+    generated: boolean;
+    template: boolean;
+}
+export declare function parseStateFrontmatter(content: string): ParsedStateFrontmatter;
+//# sourceMappingURL=parser.d.ts.map

package/dist/state/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/state/parser.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,KAAK,EACL,WAAW,EACX,YAAY,EACb,MAAM,UAAU,CAAC;AAQlB,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,aAAa,EAAE,aAAa,CAAC;IAC7B,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAClC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;CACnB;AA2BD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,sBAAsB,CAyD7E"}

package/dist/state/parser.js

@@ -0,0 +1,120 @@
+import { parseFrontmatterRecord } from '../shared/utils/frontmatter.js';
+import { normalizeNullableString, parseBoolean, } from '../shared/utils/normalize.js';
+const PHASES = ['discovery', 'spec', 'design', 'plan', 'implement'];
+const PHASE_STATUSES = ['in_progress', 'complete', 'pr_open'];
+const EXECUTION_MODES = ['single-thread', 'subagent-driven'];
+const WORKFLOW_MODES = ['spec-driven', 'quick', 'import'];
+const LIFECYCLE_VALUES = ['active', 'paused', 'complete'];
+const EMPTY_PARSED_STATE = {
+    currentTask: null,
+    lastCommit: null,
+    blockers: [],
+    hillCheckpoints: [],
+    hillCompleted: [],
+    parallelExecution: false,
+    phase: null,
+    phaseStatus: null,
+    executionMode: 'single-thread',
+    lifecycle: null,
+    pauseTimestamp: null,
+    pauseReason: null,
+    workflowMode: null,
+    workflowOrigin: null,
+    docsUpdated: null,
+    prStatus: null,
+    prUrl: null,
+    projectCreated: null,
+    projectCompleted: null,
+    projectStateUpdated: null,
+    generated: false,
+    template: false,
+};
+export function parseStateFrontmatter(content) {
+    const parsed = parseFrontmatterRecord(content);
+    if (Object.keys(parsed).length === 0) {
+        return EMPTY_PARSED_STATE;
+    }
+    return {
+        currentTask: normalizeNullableString(parsed.oat_current_task, {
+            treatPlaceholdersAsNull: true,
+        }),
+        lastCommit: normalizeNullableString(parsed.oat_last_commit, {
+            treatPlaceholdersAsNull: true,
+        }),
+        blockers: parseStringArray(parsed.oat_blockers),
+        hillCheckpoints: parseStringArray(parsed.oat_hill_checkpoints),
+        hillCompleted: parseStringArray(parsed.oat_hill_completed),
+        parallelExecution: parseBoolean(parsed.oat_parallel_execution),
+        phase: normalizeEnum(parsed.oat_phase, PHASES),
+        phaseStatus: normalizeEnum(parsed.oat_phase_status, PHASE_STATUSES),
+        executionMode: normalizeEnum(parsed.oat_execution_mode, EXECUTION_MODES) ??
+            'single-thread',
+        lifecycle: normalizeEnum(parsed.oat_lifecycle, LIFECYCLE_VALUES),
+        pauseTimestamp: normalizeNullableString(parsed.oat_pause_timestamp, {
+            treatPlaceholdersAsNull: true,
+        }),
+        pauseReason: normalizeNullableString(parsed.oat_pause_reason, {
+            treatPlaceholdersAsNull: true,
+        }),
+        workflowMode: normalizeEnum(parsed.oat_workflow_mode, WORKFLOW_MODES),
+        workflowOrigin: normalizeNullableString(parsed.oat_workflow_origin, {
+            treatPlaceholdersAsNull: true,
+        }),
+        docsUpdated: normalizeNullableString(parsed.oat_docs_updated, {
+            treatPlaceholdersAsNull: true,
+        }),
+        prStatus: normalizeNullableString(parsed.oat_pr_status, {
+            treatPlaceholdersAsNull: true,
+        }),
+        prUrl: normalizeNullableString(parsed.oat_pr_url, {
+            treatPlaceholdersAsNull: true,
+        }),
+        projectCreated: normalizeNullableString(parsed.oat_project_created, {
+            treatPlaceholdersAsNull: true,
+        }),
+        projectCompleted: normalizeNullableString(parsed.oat_project_completed, {
+            treatPlaceholdersAsNull: true,
+        }),
+        projectStateUpdated: normalizeNullableString(parsed.oat_project_state_updated, {
+            treatPlaceholdersAsNull: true,
+        }),
+        generated: parseBoolean(parsed.oat_generated),
+        template: parseBoolean(parsed.oat_template),
+    };
+}
+function parseStringArray(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => normalizeNullableString(item, { treatPlaceholdersAsNull: true }))
+            .filter((item) => item !== null);
+    }
+    if (typeof value !== 'string') {
+        return [];
+    }
+    const normalized = value.trim();
+    if (normalizeNullableString(normalized, { treatPlaceholdersAsNull: true }) ==
+        null) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(normalized);
+        if (Array.isArray(parsed)) {
+            return parsed
+                .map((item) => normalizeNullableString(item, { treatPlaceholdersAsNull: true }))
+                .filter((item) => item !== null);
+        }
+    }
+    catch {
+        return [normalized];
+    }
+    return [];
+}
+function normalizeEnum(value, allowedValues) {
+    const normalized = normalizeNullableString(value, {
+        treatPlaceholdersAsNull: true,
+    });
+    if (normalized == null) {
+        return null;
+    }
+    return allowedValues.includes(normalized) ? normalized : null;
+}

package/dist/state/reviews.d.ts

@@ -0,0 +1,4 @@
+import type { ReviewStatus } from '../types.js';
+export declare function parseReviewTable(planContent: string): ReviewStatus[];
+export declare function scanUnprocessedReviews(projectPath: string): Promise<string[]>;
+//# sourceMappingURL=reviews.d.ts.map

package/dist/state/reviews.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviews.d.ts","sourceRoot":"","sources":["../../src/state/reviews.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAI7C,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,YAAY,EAAE,CAepE;AAED,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CAgBnB"}

package/dist/state/reviews.js

@@ -0,0 +1,60 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isMissingFileError } from '../shared/utils/errors.js';
+const REVIEWS_HEADING = '## Reviews';
+export function parseReviewTable(planContent) {
+    const reviewsSection = extractReviewsSection(planContent);
+    if (reviewsSection == null) {
+        return [];
+    }
+    const rows = reviewsSection
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('|'));
+    return rows
+        .slice(2)
+        .map(parseTableRow)
+        .filter((row) => row !== null);
+}
+export async function scanUnprocessedReviews(projectPath) {
+    const reviewsPath = join(projectPath, 'reviews');
+    try {
+        const entries = await readdir(reviewsPath, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+            .map((entry) => join(reviewsPath, entry.name))
+            .sort();
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return [];
+        }
+        throw error;
+    }
+}
+function extractReviewsSection(planContent) {
+    const startIndex = planContent.indexOf(REVIEWS_HEADING);
+    if (startIndex === -1) {
+        return null;
+    }
+    const remaining = planContent.slice(startIndex + REVIEWS_HEADING.length);
+    const nextHeadingIndex = remaining.search(/\n## /);
+    if (nextHeadingIndex === -1) {
+        return remaining.trim();
+    }
+    return remaining.slice(0, nextHeadingIndex).trim();
+}
+function parseTableRow(line) {
+    const cells = line
+        .split('|')
+        .slice(1, -1)
+        .map((cell) => cell.trim());
+    if (cells.length !== 5) {
+        return null;
+    }
+    const [scope, type, status, date, artifact] = cells;
+    if (!scope || !type || !status || !date || !artifact) {
+        return null;
+    }
+    return { scope, type, status, date, artifact };
+}

package/dist/state/tasks.d.ts

@@ -0,0 +1,3 @@
+import type { TaskProgress } from '../types.js';
+export declare function parseTaskProgress(planContent: string, implementationContent: string): TaskProgress;
+//# sourceMappingURL=tasks.d.ts.map

package/dist/state/tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../src/state/tasks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAY7C,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,EACnB,qBAAqB,EAAE,MAAM,GAC5B,YAAY,CAiBd"}

package/dist/state/tasks.js

@@ -0,0 +1,85 @@
+import { parseFrontmatterRecord } from '../shared/utils/frontmatter.js';
+const PHASE_HEADING_PATTERN = /^## Phase \d+: (.+)$/m;
+const REVISION_PHASE_HEADING_PATTERN = /^## Revision Phase \d+: (.+)$/m;
+export function parseTaskProgress(planContent, implementationContent) {
+    const completedTasks = parseCompletedTaskIds(implementationContent);
+    const currentTaskId = parseCurrentTaskId(implementationContent);
+    const phases = parsePhaseProgress(planContent, completedTasks);
+    return {
+        total: phases.reduce((sum, phase) => sum + phase.total, 0),
+        completed: phases.reduce((sum, phase) => sum + phase.completed, 0),
+        currentTaskId,
+        phases: phases.map((phase) => ({
+            phaseId: phase.phaseId ?? 'unknown',
+            name: phase.name,
+            total: phase.total,
+            completed: phase.completed,
+            isRevision: phase.isRevision,
+        })),
+    };
+}
+function parsePhaseProgress(planContent, completedTasks) {
+    const phases = [];
+    const lines = planContent.split('\n');
+    let currentPhase = null;
+    for (const line of lines) {
+        if (PHASE_HEADING_PATTERN.test(line) ||
+            REVISION_PHASE_HEADING_PATTERN.test(line)) {
+            currentPhase = {
+                phaseId: null,
+                name: extractPhaseName(line),
+                total: 0,
+                completed: 0,
+                isRevision: line.startsWith('## Revision Phase'),
+            };
+            phases.push(currentPhase);
+            continue;
+        }
+        const taskMatch = line.match(/^### Task ((?:p\d+|p-rev\d+)-t\d+): (.+)$/);
+        if (!taskMatch || currentPhase == null) {
+            continue;
+        }
+        const taskId = taskMatch[1];
+        if (!taskId) {
+            continue;
+        }
+        const phaseId = taskId.replace(/-t\d+$/, '');
+        currentPhase.phaseId ??= phaseId;
+        currentPhase.total += 1;
+        currentPhase.completed += completedTasks.has(taskId) ? 1 : 0;
+    }
+    return phases.filter((phase) => phase.phaseId !== null);
+}
+function parseCompletedTaskIds(implementationContent) {
+    const completedTasks = new Set();
+    let currentTaskId = null;
+    for (const line of implementationContent.split('\n')) {
+        const taskMatch = line.match(/^### Task ((?:p\d+|p-rev\d+)-t\d+): .+$/);
+        if (taskMatch?.[1]) {
+            currentTaskId = taskMatch[1];
+            continue;
+        }
+        if (currentTaskId && /^\*\*Status:\*\*\s+completed$/.test(line.trim())) {
+            completedTasks.add(currentTaskId);
+        }
+    }
+    return completedTasks;
+}
+function parseCurrentTaskId(implementationContent) {
+    const parsed = parseFrontmatterRecord(implementationContent);
+    const currentTaskId = parsed.oat_current_task_id;
+    return typeof currentTaskId === 'string' && currentTaskId !== 'null'
+        ? currentTaskId
+        : null;
+}
+function extractPhaseName(line) {
+    const revisionMatch = line.match(/^## Revision Phase \d+: (.+)$/);
+    if (revisionMatch?.[1]) {
+        return revisionMatch[1];
+    }
+    const phaseMatch = line.match(/^## Phase \d+: (.+)$/);
+    if (phaseMatch?.[1]) {
+        return phaseMatch[1];
+    }
+    return line.replace(/^## /, '');
+}

package/dist/types.d.ts

@@ -0,0 +1,85 @@
+export type Phase = 'discovery' | 'spec' | 'design' | 'plan' | 'implement';
+export type PhaseStatus = 'in_progress' | 'complete' | 'pr_open';
+export type WorkflowMode = 'spec-driven' | 'quick' | 'import';
+export type ExecutionMode = 'single-thread' | 'subagent-driven';
+export type Lifecycle = 'active' | 'paused' | 'complete';
+export type ArtifactType = 'discovery' | 'spec' | 'design' | 'plan' | 'implementation' | 'summary';
+export type BoundaryTier = 1 | 2 | 3;
+export interface ArtifactStatus {
+    type: ArtifactType;
+    exists: boolean;
+    path: string;
+    status: string | null;
+    readyFor: string | null;
+    isTemplate: boolean;
+    boundaryTier: BoundaryTier;
+}
+export interface PhaseProgress {
+    phaseId: string;
+    name: string;
+    total: number;
+    completed: number;
+    isRevision: boolean;
+}
+export interface TaskProgress {
+    total: number;
+    completed: number;
+    currentTaskId: string | null;
+    phases: PhaseProgress[];
+}
+export interface ReviewStatus {
+    scope: string;
+    type: string;
+    status: string;
+    date: string;
+    artifact: string;
+}
+export interface SkillRecommendation {
+    skill: string;
+    reason: string;
+    context?: string;
+}
+export interface ProjectState {
+    name: string;
+    path: string;
+    phase: Phase;
+    phaseStatus: PhaseStatus;
+    workflowMode: WorkflowMode;
+    executionMode: ExecutionMode;
+    lifecycle: Lifecycle;
+    pauseTimestamp: string | null;
+    pauseReason: string | null;
+    progress: TaskProgress;
+    artifacts: ArtifactStatus[];
+    reviews: ReviewStatus[];
+    blockers: string[];
+    hillCheckpoints: string[];
+    hillCompleted: string[];
+    prStatus: string | null;
+    prUrl: string | null;
+    docsUpdated: string | null;
+    lastCommit: string | null;
+    timestamps: {
+        created: string;
+        completed: string | null;
+        stateUpdated: string;
+    };
+    recommendation: SkillRecommendation;
+}
+export interface ProjectSummary {
+    name: string;
+    path: string;
+    phase: Phase;
+    phaseStatus: PhaseStatus;
+    workflowMode: WorkflowMode;
+    lifecycle: Lifecycle;
+    progress: {
+        completed: number;
+        total: number;
+    };
+    recommendation: {
+        skill: string;
+        reason: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@open-agent-toolkit/control-plane",
+  "version": "0.0.1",
+  "private": false,
+  "description": "Read-only OAT control-plane library for structured project state",
+  "homepage": "https://github.com/voxmedia/open-agent-toolkit/tree/main/packages/control-plane",
+  "bugs": {
+    "url": "https://github.com/voxmedia/open-agent-toolkit/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/voxmedia/open-agent-toolkit.git",
+    "directory": "packages/control-plane"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "yaml": "2.8.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsc-alias": "^1.8.10",
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=22.17.0"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "dev": "tsc --watch",
+    "lint": "oxlint .",
+    "format": "oxfmt --check .",
+    "format:fix": "oxfmt .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "type-check": "tsc --noEmit"
+  }
+}