@platformos/platformos-mcp-supervisor 0.0.2

package/dist/bin/args.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pure CLI argument + project-directory resolution for the bin.
+ *
+ * Kept separate from the bin entrypoint (which runs `main()` on import) so it
+ * can be unit-tested without booting a server.
+ */
+export interface ParsedArgs {
+    projectDir?: string;
+    help: boolean;
+}
+/**
+ * Parse `--project <dir>` / `--project=<dir>` / `--help` / `-h` from a
+ * `process.argv.slice(2)`-style array. Unknown flags are tolerated so a
+ * forward-compatible client can pass extras without breaking the bin.
+ */
+export declare function parseArgs(argv: ReadonlyArray<string>): ParsedArgs;
+/**
+ * Resolve the project directory by precedence:
+ *   1. `--project` argument, 2. `POS_SUPERVISOR_PROJECT_DIR`, 3. cwd.
+ */
+export declare function resolveProjectDir(args: ParsedArgs, env: NodeJS.ProcessEnv, cwd: string): string;
+export declare const HELP = "platformos-mcp-supervisor \u2014 MCP stdio server exposing validate_code\n\nUsage:\n  platformos-mcp-supervisor [--project <dir>]\n\nOptions:\n  --project <dir>   Project root to validate against\n                    (env: POS_SUPERVISOR_PROJECT_DIR; default: current directory)\n  -h, --help        Show this help\n";

package/dist/bin/args.js

@@ -0,0 +1,41 @@
+/**
+ * Parse `--project <dir>` / `--project=<dir>` / `--help` / `-h` from a
+ * `process.argv.slice(2)`-style array. Unknown flags are tolerated so a
+ * forward-compatible client can pass extras without breaking the bin.
+ */
+export function parseArgs(argv) {
+    let projectDir;
+    let help = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--help' || arg === '-h') {
+            help = true;
+        }
+        else if (arg === '--project') {
+            projectDir = argv[i + 1];
+            i++;
+        }
+        else if (arg.startsWith('--project=')) {
+            projectDir = arg.slice('--project='.length);
+        }
+    }
+    return { projectDir, help };
+}
+/**
+ * Resolve the project directory by precedence:
+ *   1. `--project` argument, 2. `POS_SUPERVISOR_PROJECT_DIR`, 3. cwd.
+ */
+export function resolveProjectDir(args, env, cwd) {
+    return args.projectDir ?? env.POS_SUPERVISOR_PROJECT_DIR ?? cwd;
+}
+export const HELP = `platformos-mcp-supervisor — MCP stdio server exposing validate_code
+
+Usage:
+  platformos-mcp-supervisor [--project <dir>]
+
+Options:
+  --project <dir>   Project root to validate against
+                    (env: POS_SUPERVISOR_PROJECT_DIR; default: current directory)
+  -h, --help        Show this help
+`;
+//# sourceMappingURL=args.js.map

package/dist/bin/platformos-mcp-supervisor.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/platformos-mcp-supervisor.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * CLI entrypoint for the platformOS MCP supervisor.
+ *
+ * Resolves the project directory by precedence:
+ *   1. `--project <dir>` / `--project=<dir>` (wins)
+ *   2. `POS_SUPERVISOR_PROJECT_DIR` environment variable
+ *   3. `process.cwd()` — the directory the MCP client launched the bin from
+ *
+ * Boots `startServer` and lets Node keep the process alive: `server.connect()`
+ * registers the stdio transport but does not block, so the SIGINT/SIGTERM
+ * handlers installed inside `startServer` own the lifetime.
+ *
+ * The source lives under `src/bin/` (tsconfig `rootDir` is `src`); the build
+ * emits `dist/bin/platformos-mcp-supervisor.js`, which `package.json#bin`
+ * references. tsc preserves the shebang so the dist file is executable.
+ *
+ * Pure arg/dir resolution lives in `./args` so it can be unit-tested without
+ * importing this module (which boots the server on load).
+ */
+import { createLogger } from '../logger.js';
+import { startServer } from '../transport/server.js';
+import { HELP, parseArgs, resolveProjectDir } from './args.js';
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        process.stderr.write(HELP);
+        return;
+    }
+    const log = createLogger('platformos-mcp-supervisor');
+    const projectDir = resolveProjectDir(args, process.env, process.cwd());
+    await startServer({ projectDir, log });
+}
+main().catch((err) => {
+    process.stderr.write(`fatal: ${err?.stack ?? String(err)}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=platformos-mcp-supervisor.js.map

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/** Public surface of @platformos/platformos-mcp-supervisor. */
+export { startServer } from './transport/server.js';
+export type { ServerOptions, ServerHandle } from './transport/server.js';
+export { registerValidateCode, VALIDATE_CODE_INPUT } from './transport/validate-code.js';
+export type { SupervisorContext } from './transport/validate-code.js';
+export { createLogger } from './logger.js';
+export type { Logger } from './logger.js';
+export * from './result/types.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+/** Public surface of @platformos/platformos-mcp-supervisor. */
+export { startServer } from './transport/server.js';
+export { registerValidateCode, VALIDATE_CODE_INPUT } from './transport/validate-code.js';
+export { createLogger } from './logger.js';
+export * from './result/types.js';
+//# sourceMappingURL=index.js.map

package/dist/lint/lint.d.ts

@@ -0,0 +1,11 @@
+import type { ValidateCodeDiagnostic } from '../result/types.js';
+export interface RunLintParams {
+    /** Absolute project root the buffer is validated against. */
+    projectDir: string;
+    /** File under edit — absolute, or relative to `projectDir`. */
+    filePath: string;
+    /** In-memory buffer contents. */
+    content: string;
+}
+/** Lint the buffer and return the mapped diagnostics for the file. */
+export declare function runLint(params: RunLintParams): Promise<ValidateCodeDiagnostic[]>;

package/dist/lint/lint.js

@@ -0,0 +1,47 @@
+/**
+ * Lint adapter — the only I/O boundary on the request path.
+ *
+ * Lints an in-memory buffer in the context of its on-disk project via the
+ * check-node `lintBuffer` seam (a direct `check()` call — no LSP, no
+ * subprocess) and maps the structured check-common `Offense[]` into the
+ * agent-facing `ValidateCodeDiagnostic` shape.
+ *
+ * This is the minimal "lint only" slice: it carries detection results
+ * (check code, severity, message, range) straight through. Ergonomic
+ * enrichment (hints, confidence, fix translation, see-also) is added later in
+ * `enrich/`; for now diagnostics have no `fix` / `hint`, and the structured
+ * `Offense.fix` / `suggest` are intentionally not translated.
+ */
+import { isAbsolute, join } from 'node:path';
+import { lintBuffer, Severity } from '@platformos/platformos-check-node';
+const SEVERITY = {
+    [Severity.ERROR]: 'error',
+    [Severity.WARNING]: 'warning',
+    [Severity.INFO]: 'info',
+};
+/** Lint the buffer and return the mapped diagnostics for the file. */
+export async function runLint(params) {
+    const { projectDir, filePath, content } = params;
+    const absoluteFilePath = isAbsolute(filePath) ? filePath : join(projectDir, filePath);
+    const offenses = await lintBuffer({ root: projectDir, filePath: absoluteFilePath, content });
+    return offenses.map(toDiagnostic);
+}
+/**
+ * Map a check-common `Offense` to a `ValidateCodeDiagnostic`.
+ *
+ * check-common positions are 0-based for BOTH line and character
+ * (`getPosition` uses `line-column` with `origin: 0`); the agent surface uses
+ * 1-based line + 1-based column, so both get `+ 1`.
+ */
+function toDiagnostic(offense) {
+    return {
+        check: offense.check,
+        severity: SEVERITY[offense.severity],
+        message: offense.message,
+        line: offense.start.line + 1,
+        column: offense.start.character + 1,
+        end_line: offense.end.line + 1,
+        end_column: offense.end.character + 1,
+    };
+}
+//# sourceMappingURL=lint.js.map

package/dist/logger.d.ts

@@ -0,0 +1,8 @@
+/**
+ * stderr-only logger.
+ *
+ * stdout is reserved for the MCP JSON-RPC stream — anything written there
+ * corrupts the transport. Every operational log line therefore goes to stderr.
+ */
+export type Logger = (message: string) => void;
+export declare function createLogger(prefix?: string): Logger;

package/dist/logger.js

@@ -0,0 +1,7 @@
+export function createLogger(prefix) {
+    const tag = prefix ? ` ${prefix}` : '';
+    return (message) => {
+        process.stderr.write(`${new Date().toISOString()} [info]${tag}: ${message}\n`);
+    };
+}
+//# sourceMappingURL=logger.js.map

package/dist/result/assemble.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Result assembly (minimal "lint only" slice).
+ *
+ * Buckets the mapped diagnostics into errors / warnings / infos and derives the
+ * `status` + `must_fix_before_write` envelope. PURE — no I/O, consumes only the
+ * diagnostic list and the shared result types.
+ *
+ * The ergonomic transforms (clustering, scorecard, the explicit
+ * blocking-warning set, `next_step`, tips, domain_guide, structural) are added
+ * in later tasks; they are left empty/null here.
+ */
+import type { ValidateCodeDiagnostic, ValidateCodeMode, ValidateCodeResult } from './types.js';
+export declare function assembleResult(diagnostics: ValidateCodeDiagnostic[], _mode: ValidateCodeMode): ValidateCodeResult;

package/dist/result/assemble.js

@@ -0,0 +1,25 @@
+export function assembleResult(diagnostics, 
+// Reserved: `full`/`quick` do not yet change output (no heavier stages exist).
+_mode) {
+    const errors = diagnostics.filter((d) => d.severity === 'error');
+    const warnings = diagnostics.filter((d) => d.severity === 'warning');
+    const infos = diagnostics.filter((d) => d.severity === 'info');
+    const status = errors.length > 0 ? 'error' : warnings.length > 0 ? 'warning' : 'ok';
+    return {
+        status,
+        // Minimal gate: any error blocks the write. The richer blocking-warning set
+        // is defined in the result-assembly task.
+        must_fix_before_write: errors.length > 0,
+        errors,
+        warnings,
+        infos,
+        proposed_fixes: [],
+        clusters: [],
+        scorecard: [],
+        parse_error: null,
+        tips: [],
+        domain_guide: null,
+        structural: null,
+    };
+}
+//# sourceMappingURL=assemble.js.map

package/dist/result/types.d.ts

@@ -0,0 +1,155 @@
+/**
+ * The `validate_code` result contract — the agent-facing surface of the
+ * supervisor.
+ *
+ * This is intentionally separate from check-common's `Offense`: `Offense` is a
+ * stable, minimal detection type consumed by editors/CLI/browser, whereas
+ * `ValidateCodeResult` is an LLM-ergonomics surface that may churn as agent
+ * behaviour is tuned. The `result/` layer assembles this shape from enriched
+ * diagnostics + advisories via order-independent pure transforms.
+ *
+ * Field names mirror the v1 supervisor so the parity safety net (TASK-8.5) can
+ * compare unchanged-contract fields against the captured baselines. Fields
+ * marked "TASK-8" are part of the contract but are only populated once the
+ * supervisor's per-domain layer and rule library are restored; the minimal
+ * TASK-7 build leaves them empty / null.
+ */
+export type ValidateCodeMode = 'full' | 'quick';
+export type ValidateCodeStatus = 'ok' | 'warning' | 'error';
+export type ValidateCodeSeverity = 'error' | 'warning' | 'info';
+/** Tool input. */
+export interface ValidateCodeParams {
+    /** Path of the file under edit (absolute, or relative to the project root). */
+    file_path: string;
+    /** The file contents to validate (the in-memory buffer). */
+    content: string;
+    /** Depth of analysis. Defaults to `full`. */
+    mode?: ValidateCodeMode;
+}
+/**
+ * An agent-facing fix. Translated from a check-common `FixDescription` (the
+ * structured edits the engine already computed); the supervisor never
+ * regenerates edit text from scratch.
+ *
+ * - `text_edit` — replace `[start_index, end_index)` with `new_text`.
+ * - `insert`    — insert `new_text` at `start_index` (`end_index === start_index`).
+ * - `guidance`  — prose only; no machine-applicable edit.
+ */
+export type AgentFix = {
+    type: 'text_edit' | 'insert';
+    description?: string;
+    /** 0-based offset into the file. */
+    start_index: number;
+    /** 0-based offset into the file. */
+    end_index: number;
+    new_text: string;
+} | {
+    type: 'guidance';
+    description: string;
+};
+/**
+ * A diagnostic as surfaced to the agent. Carries the structured check-common
+ * fields (`check`, `severity`, range, `message`) plus the supervisor's
+ * ergonomic enrichment (`hint`, `suggestion`, `confidence`, `fix`, `see_also`).
+ * Line/column are 1-based (converted from check-common's 0-based offsets in the
+ * `result/` layer).
+ */
+export interface ValidateCodeDiagnostic {
+    /** The check code, e.g. `MissingPartial`, or a `pos-supervisor:` advisory code. */
+    check: string;
+    severity: ValidateCodeSeverity;
+    message: string;
+    /** 1-based line of the diagnostic start. */
+    line: number;
+    /** 1-based column of the diagnostic start. */
+    column: number;
+    /** 1-based line of the diagnostic end, when known. */
+    end_line?: number;
+    /** 1-based column of the diagnostic end, when known. */
+    end_column?: number;
+    /** Markdown explanation for the agent. */
+    hint?: string;
+    /** A short, one-line "did you mean / use this" pointer. */
+    suggestion?: string;
+    /** Static confidence in [0, 1] that this diagnostic + its fix are correct. */
+    confidence?: number;
+    /** A single concrete fix for this diagnostic, when one is available. */
+    fix?: AgentFix;
+    /** A pointer to another supervisor tool / doc that helps resolve this. */
+    see_also?: SeeAlso;
+}
+export interface SeeAlso {
+    tool?: string;
+    args?: Record<string, unknown>;
+    reason?: string;
+}
+/**
+ * A proposed fix shown to the agent at the top level of the result. Carries the
+ * originating `check` so the agent can correlate it with a diagnostic.
+ */
+export type ProposedFix = AgentFix & {
+    check?: string | null;
+};
+/** A group of related diagnostics sharing a root cause, with a unified remedy. */
+export interface DiagnosticCluster {
+    check: string;
+    count: number;
+    unified_fix?: string;
+}
+/** An advisory note about the file's architecture (doc-block coverage, layout correctness, …). */
+export interface ScorecardNote {
+    category: string;
+    status: 'ok' | 'warning' | 'info';
+    reason: string;
+}
+export interface TipEntry {
+    id: string;
+    severity: string;
+    message: string;
+}
+export interface DomainGuideGotcha {
+    id: string;
+    message: string;
+    severity: string;
+    applies_to_errors?: string[];
+}
+export interface DomainGuide {
+    domain: string;
+    rule?: string;
+    triggered_gotchas: DomainGuideGotcha[];
+}
+export interface ValidateCodeStructuralSnapshot {
+    renders_used: string[];
+    filters_used: string[];
+    tags_used: string[];
+    translation_keys: string[];
+    doc_params: string[];
+    slug: string | null;
+    layout: string | null;
+    method: string | null;
+}
+/**
+ * The full `validate_code` result. Serialized as a single JSON text block over
+ * the MCP stdio transport.
+ */
+export interface ValidateCodeResult {
+    status: ValidateCodeStatus;
+    /**
+     * When true the agent MUST NOT write the file. Set by any error or any
+     * "blocking" warning (the blocking set is defined explicitly in `result/`).
+     */
+    must_fix_before_write: boolean;
+    errors: ValidateCodeDiagnostic[];
+    warnings: ValidateCodeDiagnostic[];
+    infos: ValidateCodeDiagnostic[];
+    proposed_fixes: ProposedFix[];
+    clusters: DiagnosticCluster[];
+    scorecard: ScorecardNote[];
+    /** Deterministic prose telling the agent what to do next. */
+    next_step?: string;
+    /** Parse-failure message when the file could not be parsed at all; null/absent otherwise. */
+    parse_error?: string | null;
+    tips?: TipEntry[];
+    domain_guide?: DomainGuide | null;
+    structural?: ValidateCodeStructuralSnapshot | null;
+}

package/dist/result/types.js

@@ -0,0 +1,18 @@
+/**
+ * The `validate_code` result contract — the agent-facing surface of the
+ * supervisor.
+ *
+ * This is intentionally separate from check-common's `Offense`: `Offense` is a
+ * stable, minimal detection type consumed by editors/CLI/browser, whereas
+ * `ValidateCodeResult` is an LLM-ergonomics surface that may churn as agent
+ * behaviour is tuned. The `result/` layer assembles this shape from enriched
+ * diagnostics + advisories via order-independent pure transforms.
+ *
+ * Field names mirror the v1 supervisor so the parity safety net (TASK-8.5) can
+ * compare unchanged-contract fields against the captured baselines. Fields
+ * marked "TASK-8" are part of the contract but are only populated once the
+ * supervisor's per-domain layer and rule library are restored; the minimal
+ * TASK-7 build leaves them empty / null.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/transport/server.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MCP stdio server lifecycle.
+ *
+ * `startServer` wires an `McpServer` to a `StdioServerTransport`, registers the
+ * `validate_code` tool, and installs SIGINT/SIGTERM handlers. It is the
+ * embedding surface; the bin (`bin/platformos-mcp-supervisor.ts`) is the
+ * user-facing surface.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type Logger } from '../logger.js';
+import { type SupervisorContext } from './validate-code.js';
+export interface ServerOptions {
+    /** Absolute project root that buffers are validated against. */
+    projectDir: string;
+    /** Logger sink (stderr by default). */
+    log?: Logger;
+    /** Advertised server version. */
+    version?: string;
+}
+export interface ServerHandle {
+    server: McpServer;
+    context: SupervisorContext;
+    /** Tear down the transport. Idempotent. */
+    shutdown: (reason?: string) => Promise<void>;
+}
+export declare function startServer(opts: ServerOptions): Promise<ServerHandle>;

package/dist/transport/server.js

@@ -0,0 +1,42 @@
+/**
+ * MCP stdio server lifecycle.
+ *
+ * `startServer` wires an `McpServer` to a `StdioServerTransport`, registers the
+ * `validate_code` tool, and installs SIGINT/SIGTERM handlers. It is the
+ * embedding surface; the bin (`bin/platformos-mcp-supervisor.ts`) is the
+ * user-facing surface.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createLogger } from '../logger.js';
+import { registerValidateCode } from './validate-code.js';
+const SERVER_NAME = 'platformos-mcp-supervisor';
+const DEFAULT_VERSION = '0.0.1';
+export async function startServer(opts) {
+    const log = opts.log ?? createLogger(SERVER_NAME);
+    const context = { projectDir: opts.projectDir, log };
+    const server = new McpServer({ name: SERVER_NAME, version: opts.version ?? DEFAULT_VERSION });
+    registerValidateCode(server, context);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    log(`listening on stdio (project: ${opts.projectDir})`);
+    let closed = false;
+    const shutdown = async (reason) => {
+        if (closed)
+            return;
+        closed = true;
+        if (reason)
+            log(`shutting down (${reason})`);
+        await server.close();
+    };
+    installSignalHandlers(shutdown);
+    return { server, context, shutdown };
+}
+function installSignalHandlers(shutdown) {
+    for (const signal of ['SIGINT', 'SIGTERM']) {
+        process.once(signal, () => {
+            void shutdown(signal).finally(() => process.exit(0));
+        });
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/transport/validate-code.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Registration of the `validate_code` MCP tool.
+ *
+ * Current slice: the handler runs the real lint (`check()` via the check-node
+ * seam) and returns the detection results mapped into `ValidateCodeResult`.
+ * The ergonomic stages (enrich → advise → richer result assembly) are layered
+ * in by later tasks; the handler shape stays the same.
+ */
+import { type ZodRawShape } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { Logger } from '../logger.js';
+/** Per-server context threaded into the handler. */
+export interface SupervisorContext {
+    /** Absolute project root the buffer is validated against. */
+    projectDir: string;
+    log: Logger;
+}
+/**
+ * zod raw shape for the tool input (validated by the MCP SDK before dispatch).
+ *
+ * Typed as `ZodRawShape` (not the inferred literal shape) so the SDK's
+ * `registerTool` does not perform excessively deep type instantiation over the
+ * schema; the handler casts the validated args to `ValidateCodeParams`.
+ */
+export declare const VALIDATE_CODE_INPUT: ZodRawShape;
+export declare function registerValidateCode(server: McpServer, ctx: SupervisorContext): void;

package/dist/transport/validate-code.js

@@ -0,0 +1,49 @@
+/**
+ * Registration of the `validate_code` MCP tool.
+ *
+ * Current slice: the handler runs the real lint (`check()` via the check-node
+ * seam) and returns the detection results mapped into `ValidateCodeResult`.
+ * The ergonomic stages (enrich → advise → richer result assembly) are layered
+ * in by later tasks; the handler shape stays the same.
+ */
+import { z } from 'zod';
+import { runLint } from '../lint/lint.js';
+import { assembleResult } from '../result/assemble.js';
+/**
+ * zod raw shape for the tool input (validated by the MCP SDK before dispatch).
+ *
+ * Typed as `ZodRawShape` (not the inferred literal shape) so the SDK's
+ * `registerTool` does not perform excessively deep type instantiation over the
+ * schema; the handler casts the validated args to `ValidateCodeParams`.
+ */
+export const VALIDATE_CODE_INPUT = {
+    file_path: z
+        .string()
+        .describe('Path of the file under edit (absolute, or relative to the project root).'),
+    content: z.string().describe('The file contents to validate (the in-memory buffer).'),
+    mode: z
+        .enum(['full', 'quick'])
+        .optional()
+        .describe('Analysis depth. `full` (default) runs the heavier ergonomic stages; `quick` is lint + enrichment.'),
+};
+const DESCRIPTION = 'Validate a platformOS Liquid/GraphQL/YAML file before writing it. Returns structured errors, ' +
+    'warnings, infos, proposed fixes, and a must_fix_before_write gate.';
+export function registerValidateCode(server, ctx) {
+    server.registerTool('validate_code', { description: DESCRIPTION, inputSchema: VALIDATE_CODE_INPUT }, async (args) => toToolResult(await runValidateCode(ctx, args)));
+}
+/** Lint the buffer via the check-node seam and assemble the result. */
+async function runValidateCode(ctx, params) {
+    const mode = params.mode ?? 'full';
+    ctx.log(`validate_code: ${params.file_path} (${mode})`);
+    const diagnostics = await runLint({
+        projectDir: ctx.projectDir,
+        filePath: params.file_path,
+        content: params.content,
+    });
+    return assembleResult(diagnostics, mode);
+}
+/** Wrap a result in the MCP text-content envelope (every result is one JSON text block). */
+function toToolResult(result) {
+    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+}
+//# sourceMappingURL=validate-code.js.map

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@platformos/platformos-mcp-supervisor",
+  "version": "0.0.2",
+  "description": "platformOS Model Context Protocol (MCP) server exposing validate_code for LLM agents.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "author": "platformOS",
+  "homepage": "https://github.com/Platform-OS/platformos-tools/tree/master/packages/platformos-mcp-supervisor#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Platform-OS/platformos-tools.git",
+    "directory": "packages/platformos-mcp-supervisor"
+  },
+  "bugs": {
+    "url": "https://github.com/Platform-OS/platformos-tools/issues"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "@platformos:registry": "https://registry.npmjs.org"
+  },
+  "bin": {
+    "platformos-mcp-supervisor": "dist/bin/platformos-mcp-supervisor.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/data/**/*"
+  ],
+  "scripts": {
+    "build": "yarn build:ts",
+    "build:ci": "yarn build",
+    "build:ts": "tsc -b tsconfig.build.json",
+    "dev": "tsc --watch",
+    "test": "vitest",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@platformos/platformos-check-common": "0.0.20",
+    "@platformos/platformos-check-docs-updater": "0.0.20",
+    "@platformos/platformos-check-node": "0.0.20",
+    "@platformos/platformos-graph": "0.0.20",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {}
+}