@jagilber-org/index-server 1.28.10 → 1.28.19

package/dist/schemas/index.d.ts

@@ -1,167 +1,10 @@
-export declare const instructionEntry: {
-    readonly type: "object";
-    readonly additionalProperties: false;
-    readonly $defs: {
-        readonly extensionValue: {
-            readonly anyOf: readonly [{
-                readonly type: "string";
-            }, {
-                readonly type: "number";
-            }, {
-                readonly type: "boolean";
-            }, {
-                readonly type: "array";
-                readonly items: {
-                    readonly $ref: "#/$defs/extensionValue";
-                };
-            }, {
-                readonly type: "object";
-                readonly additionalProperties: {
-                    readonly $ref: "#/$defs/extensionValue";
-                };
-            }];
-        };
-    };
-    readonly required: readonly ["id", "title", "body", "priority", "audience", "requirement", "categories", "sourceHash", "schemaVersion", "createdAt", "updatedAt", "version", "status", "owner", "priorityTier", "classification", "lastReviewedAt", "nextReviewDue", "changeLog", "semanticSummary", "contentType"];
-    readonly properties: {
-        readonly id: {
-            readonly type: "string";
-            readonly minLength: 1;
-        };
-        readonly title: {
-            readonly type: "string";
-        };
-        readonly body: {
-            readonly type: "string";
-        };
-        readonly rationale: {
-            readonly type: "string";
-        };
-        readonly priority: {
-            readonly type: "number";
-        };
-        readonly audience: {
-            readonly enum: readonly ["individual", "group", "all"];
-        };
-        readonly requirement: {
-            readonly enum: readonly ["mandatory", "critical", "recommended", "optional", "deprecated"];
-        };
-        readonly categories: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-        };
-        readonly primaryCategory: {
-            readonly type: "string";
-        };
-        readonly sourceHash: {
-            readonly type: "string";
-        };
-        readonly schemaVersion: {
-            readonly type: "string";
-        };
-        readonly deprecatedBy: {
-            readonly type: "string";
-        };
-        readonly createdAt: {
-            readonly type: "string";
-        };
-        readonly updatedAt: {
-            readonly type: "string";
-        };
-        readonly usageCount: {
-            readonly type: "number";
-        };
-        readonly firstSeenTs: {
-            readonly type: "string";
-        };
-        readonly lastUsedAt: {
-            readonly type: "string";
-        };
-        readonly riskScore: {
-            readonly type: "number";
-        };
-        readonly reviewIntervalDays: {
-            readonly type: "number";
-        };
-        readonly workspaceId: {
-            readonly type: "string";
-        };
-        readonly userId: {
-            readonly type: "string";
-        };
-        readonly teamIds: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-        };
-        readonly contentType: {
-            readonly enum: readonly ["instruction", "template", "workflow", "reference", "example", "agent"];
-        };
-        readonly version: {
-            readonly type: "string";
-        };
-        readonly status: {
-            readonly enum: readonly ["draft", "review", "approved", "deprecated"];
-        };
-        readonly owner: {
-            readonly type: "string";
-        };
-        readonly priorityTier: {
-            readonly enum: readonly ["P1", "P2", "P3", "P4"];
-        };
-        readonly classification: {
-            readonly enum: readonly ["public", "internal", "restricted"];
-        };
-        readonly lastReviewedAt: {
-            readonly type: "string";
-        };
-        readonly nextReviewDue: {
-            readonly type: "string";
-        };
-        readonly changeLog: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "object";
-                readonly required: readonly ["version", "changedAt", "summary"];
-                readonly additionalProperties: false;
-                readonly properties: {
-                    readonly version: {
-                        readonly type: "string";
-                    };
-                    readonly changedAt: {
-                        readonly type: "string";
-                    };
-                    readonly summary: {
-                        readonly type: "string";
-                    };
-                };
-            };
-        };
-        readonly supersedes: {
-            readonly type: "string";
-        };
-        readonly archivedAt: {
-            readonly type: "string";
-        };
-        readonly semanticSummary: {
-            readonly type: "string";
-        };
-        readonly createdByAgent: {
-            readonly type: "string";
-        };
-        readonly sourceWorkspace: {
-            readonly type: "string";
-        };
-        readonly extensions: {
-            readonly type: "object";
-            readonly additionalProperties: {
-                readonly $ref: "#/$defs/extensionValue";
-            };
-        };
-    };
+export { RECORD_SCHEMA, INPUT_SCHEMA, splitEntry, RECORD_PROPERTY_KEYS, INPUT_KEYS, SERVER_MANAGED_KEYS, REQUIRED_RECORD_KEYS, REQUIRED_INPUT_KEYS, validateRecord, validateInput, buildToolInputEntrySchema, INSTRUCTION_INPUT_SCHEMA_REF, INSTRUCTION_RECORD_SCHEMA_REF, } from './instructionSchema';
+export declare const instructionEntry: Record<string, unknown> & {
+    properties?: Record<string, Record<string, unknown> & /*elided*/ any>;
+    required?: string[];
+    additionalProperties?: boolean | (Record<string, unknown> & /*elided*/ any);
+    $defs?: Record<string, Record<string, unknown> & /*elided*/ any>;
+    definitions?: Record<string, Record<string, unknown> & /*elided*/ any>;
 };
 export declare const schemas: Record<string, unknown>;
 export type SchemaMap = typeof schemas;

package/dist/schemas/index.js

@@ -1,66 +1,31 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemas = exports.instructionEntry = exports.INSTRUCTION_RECORD_SCHEMA_REF = exports.INSTRUCTION_INPUT_SCHEMA_REF = exports.buildToolInputEntrySchema = exports.validateInput = exports.validateRecord = exports.REQUIRED_INPUT_KEYS = exports.REQUIRED_RECORD_KEYS = exports.SERVER_MANAGED_KEYS = exports.INPUT_KEYS = exports.RECORD_PROPERTY_KEYS = exports.splitEntry = exports.INPUT_SCHEMA = exports.RECORD_SCHEMA = void 0;
 // JSON Schemas for tool response contracts. These are used in tests to lock interfaces.
 // Increment version in docs/tools.md when changing any stable schema.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.schemas = exports.instructionEntry = void 0;
-exports.instructionEntry = {
-    type: 'object',
-    additionalProperties: false,
-    $defs: {
-        extensionValue: {
-            anyOf: [
-                { type: 'string' },
-                { type: 'number' },
-                { type: 'boolean' },
-                { type: 'array', items: { $ref: '#/$defs/extensionValue' } },
-                { type: 'object', additionalProperties: { $ref: '#/$defs/extensionValue' } }
-            ]
-        }
-    },
-    required: [
-        'id', 'title', 'body', 'priority', 'audience', 'requirement', 'categories', 'sourceHash', 'schemaVersion', 'createdAt', 'updatedAt',
-        'version', 'status', 'owner', 'priorityTier', 'classification', 'lastReviewedAt', 'nextReviewDue', 'changeLog', 'semanticSummary', 'contentType'
-    ],
-    properties: {
-        id: { type: 'string', minLength: 1 },
-        title: { type: 'string' },
-        body: { type: 'string' },
-        rationale: { type: 'string' },
-        priority: { type: 'number' },
-        audience: { enum: ['individual', 'group', 'all'] },
-        requirement: { enum: ['mandatory', 'critical', 'recommended', 'optional', 'deprecated'] },
-        categories: { type: 'array', items: { type: 'string' } },
-        primaryCategory: { type: 'string' },
-        sourceHash: { type: 'string' },
-        schemaVersion: { type: 'string' },
-        deprecatedBy: { type: 'string' },
-        createdAt: { type: 'string' },
-        updatedAt: { type: 'string' },
-        usageCount: { type: 'number' },
-        firstSeenTs: { type: 'string' },
-        lastUsedAt: { type: 'string' },
-        riskScore: { type: 'number' },
-        reviewIntervalDays: { type: 'number' },
-        workspaceId: { type: 'string' },
-        userId: { type: 'string' },
-        teamIds: { type: 'array', items: { type: 'string' } },
-        contentType: { enum: ['instruction', 'template', 'workflow', 'reference', 'example', 'agent'] },
-        version: { type: 'string' },
-        status: { enum: ['draft', 'review', 'approved', 'deprecated'] },
-        owner: { type: 'string' },
-        priorityTier: { enum: ['P1', 'P2', 'P3', 'P4'] },
-        classification: { enum: ['public', 'internal', 'restricted'] },
-        lastReviewedAt: { type: 'string' },
-        nextReviewDue: { type: 'string' },
-        changeLog: { type: 'array', items: { type: 'object', required: ['version', 'changedAt', 'summary'], additionalProperties: false, properties: { version: { type: 'string' }, changedAt: { type: 'string' }, summary: { type: 'string' } } } },
-        supersedes: { type: 'string' },
-        archivedAt: { type: 'string' },
-        semanticSummary: { type: 'string' },
-        createdByAgent: { type: 'string' },
-        sourceWorkspace: { type: 'string' },
-        extensions: { type: 'object', additionalProperties: { $ref: '#/$defs/extensionValue' } }
-    }
-};
+//
+// SOURCE OF TRUTH: instruction record/input schemas are derived from
+// schemas/instruction.schema.json via src/schemas/instructionSchema.ts.
+// This module re-exports them under their historic names so existing
+// consumers keep working without restating the schema. Do NOT inline a
+// copy here again — every duplicate causes the kind of drift that
+// broke import round-trips.
+const instructionSchema_1 = require("./instructionSchema");
+var instructionSchema_2 = require("./instructionSchema");
+Object.defineProperty(exports, "RECORD_SCHEMA", { enumerable: true, get: function () { return instructionSchema_2.RECORD_SCHEMA; } });
+Object.defineProperty(exports, "INPUT_SCHEMA", { enumerable: true, get: function () { return instructionSchema_2.INPUT_SCHEMA; } });
+Object.defineProperty(exports, "splitEntry", { enumerable: true, get: function () { return instructionSchema_2.splitEntry; } });
+Object.defineProperty(exports, "RECORD_PROPERTY_KEYS", { enumerable: true, get: function () { return instructionSchema_2.RECORD_PROPERTY_KEYS; } });
+Object.defineProperty(exports, "INPUT_KEYS", { enumerable: true, get: function () { return instructionSchema_2.INPUT_KEYS; } });
+Object.defineProperty(exports, "SERVER_MANAGED_KEYS", { enumerable: true, get: function () { return instructionSchema_2.SERVER_MANAGED_KEYS; } });
+Object.defineProperty(exports, "REQUIRED_RECORD_KEYS", { enumerable: true, get: function () { return instructionSchema_2.REQUIRED_RECORD_KEYS; } });
+Object.defineProperty(exports, "REQUIRED_INPUT_KEYS", { enumerable: true, get: function () { return instructionSchema_2.REQUIRED_INPUT_KEYS; } });
+Object.defineProperty(exports, "validateRecord", { enumerable: true, get: function () { return instructionSchema_2.validateRecord; } });
+Object.defineProperty(exports, "validateInput", { enumerable: true, get: function () { return instructionSchema_2.validateInput; } });
+Object.defineProperty(exports, "buildToolInputEntrySchema", { enumerable: true, get: function () { return instructionSchema_2.buildToolInputEntrySchema; } });
+Object.defineProperty(exports, "INSTRUCTION_INPUT_SCHEMA_REF", { enumerable: true, get: function () { return instructionSchema_2.INSTRUCTION_INPUT_SCHEMA_REF; } });
+Object.defineProperty(exports, "INSTRUCTION_RECORD_SCHEMA_REF", { enumerable: true, get: function () { return instructionSchema_2.INSTRUCTION_RECORD_SCHEMA_REF; } });
+exports.instructionEntry = instructionSchema_1.RECORD_SCHEMA;
 // (listLike schema removed after dispatcher consolidation of read-only instruction methods)
 // Using unknown for schema values to avoid any and preserve flexibility
 exports.schemas = {
@@ -89,9 +54,26 @@ exports.schemas = {
     'index_import': {
         anyOf: [
             { type: 'object', required: ['error'], properties: { error: { type: 'string' } }, additionalProperties: true },
-            { type: 'object', required: ['hash', 'imported', 'skipped', 'overwritten', 'errors', 'total'], additionalProperties: false, properties: {
-                    hash: { type: 'string' }, imported: { type: 'number' }, skipped: { type: 'number' }, overwritten: { type: 'number' }, total: { type: 'number' }, errors: { type: 'array', items: { type: 'object', required: ['id', 'error'], properties: { id: { type: 'string' }, error: { type: 'string' } }, additionalProperties: false } }
-                } }
+            { type: 'object',
+                required: ['hash', 'imported', 'skipped', 'overwritten', 'errors', 'total', 'verified', 'verifiedCount', 'verificationErrorCount', 'stripped'],
+                additionalProperties: false,
+                properties: {
+                    hash: { type: 'string' },
+                    imported: { type: 'number' },
+                    skipped: { type: 'number' },
+                    overwritten: { type: 'number' },
+                    total: { type: 'number' },
+                    errors: { type: 'array', items: { type: 'object', required: ['id', 'error'], properties: { id: { type: 'string' }, error: { type: 'string' } }, additionalProperties: false } },
+                    verified: { type: 'boolean', description: 'True when every written entry was readable in the post-write reload (verifiedCount === written count, verificationErrorCount === 0).' },
+                    verifiedCount: { type: 'number', description: 'Number of newly written/overwritten entries successfully read back after reload.' },
+                    verificationErrorCount: { type: 'number', description: 'Number of newly written entries missing from the index after the post-write reload.' },
+                    stripped: {
+                        type: 'object',
+                        description: 'Per-key counts of server-managed fields (e.g. createdAt, updatedAt, sourceHash, schemaVersion) partitioned out of caller payloads via splitEntry. Empty object when no server-managed fields were supplied.',
+                        additionalProperties: { type: 'number' },
+                    },
+                }
+            }
         ]
     },
     'index_repair': { type: 'object', required: ['repaired', 'updated'], additionalProperties: false, properties: { repaired: { type: 'number' }, updated: { type: 'array', items: { type: 'string' } } } },

package/dist/schemas/instructionSchema.d.ts

@@ -0,0 +1,46 @@
+import { ValidateFunction } from 'ajv';
+type JsonSchema = Record<string, unknown> & {
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchema;
+    $defs?: Record<string, JsonSchema>;
+    definitions?: Record<string, JsonSchema>;
+};
+export declare const RECORD_PROPERTY_KEYS: ReadonlySet<string>;
+export declare const SERVER_MANAGED_KEYS: ReadonlySet<string>;
+export declare const INPUT_KEYS: ReadonlySet<string>;
+export declare const REQUIRED_RECORD_KEYS: ReadonlySet<string>;
+export declare const REQUIRED_INPUT_KEYS: ReadonlySet<string>;
+export declare const RECORD_SCHEMA: JsonSchema;
+export declare const INPUT_SCHEMA: JsonSchema;
+export interface SplitEntryResult<T extends Record<string, unknown> = Record<string, unknown>> {
+    input: Partial<T>;
+    serverManaged: Partial<T>;
+    unknown: Partial<T>;
+}
+export declare function splitEntry<T extends Record<string, unknown>>(entry: T | null | undefined): SplitEntryResult<T>;
+export declare const validateRecord: ValidateFunction;
+export declare const validateInput: ValidateFunction;
+export declare const INSTRUCTION_INPUT_SCHEMA_REF = "index_add#input";
+export declare const INSTRUCTION_RECORD_SCHEMA_REF: string;
+/**
+ * Build a tool-registry-friendly variant of INPUT_SCHEMA with a caller-supplied
+ * required[] minimum and a custom $id.
+ *
+ * Different MCP tool surfaces accept different "minimum required" shapes for
+ * the SAME underlying entry contract:
+ *
+ *   - index_add accepts { id, body } at minimum (handler defaults the rest)
+ *   - index_import requires { id, title, body, priority, audience, requirement }
+ *
+ * Both must still reject server-managed properties (additionalProperties:false +
+ * server-managed keys stripped) and use the same property definitions, enums,
+ * and patterns. This helper produces that variant from the canonical INPUT
+ * schema so the tool-discovery surface advertised over MCP cannot drift from
+ * the on-disk validation surface.
+ */
+export declare function buildToolInputEntrySchema(opts: {
+    required: string[];
+    schemaId?: string;
+}): JsonSchema;
+export {};

package/dist/schemas/instructionSchema.js

@@ -0,0 +1,159 @@
+"use strict";
+// Single source of truth for the instruction record contract.
+//
+// The canonical JSON Schema lives at schemas/instruction.schema.json. This
+// module loads it ONCE and derives every downstream artifact from it:
+//
+//   * RECORD_SCHEMA        — full record (used to validate on-disk entries
+//                            and exports)
+//   * INPUT_SCHEMA         — write-API contract: properties whose
+//                            x-fieldClass is "server-managed" are stripped,
+//                            additionalProperties is forced to false,
+//                            required is filtered to input-only fields.
+//   * RECORD_PROPERTY_KEYS — every property name on the canonical schema
+//   * INPUT_KEYS           — properties accepted from callers
+//   * SERVER_MANAGED_KEYS  — properties owned by the server (exports show
+//                            them, input must not)
+//   * REQUIRED_RECORD_KEYS — required[] from the canonical schema
+//   * REQUIRED_INPUT_KEYS  — required[] minus server-managed
+//   * splitEntry()         — partition a payload into
+//                            { input, serverManaged, unknown }
+//   * compiled validators  — validateRecord, validateInput
+//
+// Every other module in this codebase MUST import these derived artifacts
+// instead of restating the schema. See instructionRecordValidation.ts and
+// services/handlers/instructions.{add,import}.ts for the canonical
+// consumers.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTRUCTION_RECORD_SCHEMA_REF = exports.INSTRUCTION_INPUT_SCHEMA_REF = exports.validateInput = exports.validateRecord = exports.INPUT_SCHEMA = exports.RECORD_SCHEMA = exports.REQUIRED_INPUT_KEYS = exports.REQUIRED_RECORD_KEYS = exports.INPUT_KEYS = exports.SERVER_MANAGED_KEYS = exports.RECORD_PROPERTY_KEYS = void 0;
+exports.splitEntry = splitEntry;
+exports.buildToolInputEntrySchema = buildToolInputEntrySchema;
+const ajv_1 = __importDefault(require("ajv"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const json_schema_draft_07_json_1 = __importDefault(require("ajv/dist/refs/json-schema-draft-07.json"));
+const instruction_schema_json_1 = __importDefault(require("../../schemas/instruction.schema.json"));
+const CANONICAL = instruction_schema_json_1.default;
+function deepClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function isServerManaged(prop) {
+    if (!prop || typeof prop !== 'object')
+        return false;
+    return prop['x-fieldClass'] === 'server-managed';
+}
+const allProps = (CANONICAL.properties ?? {});
+const requiredRecord = (CANONICAL.required ?? []);
+exports.RECORD_PROPERTY_KEYS = new Set(Object.keys(allProps));
+exports.SERVER_MANAGED_KEYS = new Set(Object.entries(allProps)
+    .filter(([, def]) => isServerManaged(def))
+    .map(([name]) => name));
+exports.INPUT_KEYS = new Set(Object.keys(allProps).filter((name) => !exports.SERVER_MANAGED_KEYS.has(name)));
+exports.REQUIRED_RECORD_KEYS = new Set(requiredRecord);
+exports.REQUIRED_INPUT_KEYS = new Set(requiredRecord.filter((name) => !exports.SERVER_MANAGED_KEYS.has(name)));
+// RECORD_SCHEMA: the canonical schema, deep-cloned so consumers cannot
+// mutate the loaded module.
+exports.RECORD_SCHEMA = deepClone(CANONICAL);
+// INPUT_SCHEMA: derived. Strip server-managed properties, drop them from
+// required[], force additionalProperties:false. Same $defs, same enum
+// values, same patterns — single source.
+exports.INPUT_SCHEMA = (() => {
+    const cloned = deepClone(CANONICAL);
+    const props = (cloned.properties ?? {});
+    const filteredProps = {};
+    for (const [name, def] of Object.entries(props)) {
+        if (exports.SERVER_MANAGED_KEYS.has(name))
+            continue;
+        filteredProps[name] = def;
+    }
+    cloned.properties = filteredProps;
+    cloned.required = (cloned.required ?? []).filter((name) => !exports.SERVER_MANAGED_KEYS.has(name));
+    cloned.additionalProperties = false;
+    // Distinguish the derived schema in error messages.
+    cloned.$id = 'index_add#input';
+    cloned.title = 'InstructionInput';
+    return cloned;
+})();
+function splitEntry(entry) {
+    const result = { input: {}, serverManaged: {}, unknown: {} };
+    if (!entry || typeof entry !== 'object')
+        return result;
+    for (const [key, value] of Object.entries(entry)) {
+        if (exports.SERVER_MANAGED_KEYS.has(key)) {
+            result.serverManaged[key] = value;
+        }
+        else if (exports.INPUT_KEYS.has(key)) {
+            result.input[key] = value;
+        }
+        else {
+            result.unknown[key] = value;
+        }
+    }
+    return result;
+}
+// Compiled validators. Construct a single Ajv instance and register both
+// schemas so error messages can reference the right $id.
+const ajv = new ajv_1.default({ allErrors: true, strict: false });
+(0, ajv_formats_1.default)(ajv);
+// Register the draft-07 meta schema under both URIs Ajv may look up
+// (with and without trailing '#'), since the canonical schema declares
+// `$schema: "https://json-schema.org/draft-07/schema#"` and Ajv will
+// validate it on compile.
+for (const id of [
+    'https://json-schema.org/draft-07/schema',
+    'https://json-schema.org/draft-07/schema#',
+    'http://json-schema.org/draft-07/schema',
+    'http://json-schema.org/draft-07/schema#',
+]) {
+    try {
+        if (!ajv.getSchema(id))
+            ajv.addMetaSchema(json_schema_draft_07_json_1.default, id);
+    }
+    catch {
+        // Non-fatal: Ajv refuses to register the meta schema twice across a hot
+        // module reload. Same defensive pattern used by the legacy validator.
+    }
+}
+exports.validateRecord = ajv.compile(deepClone(exports.RECORD_SCHEMA));
+exports.validateInput = ajv.compile(deepClone(exports.INPUT_SCHEMA));
+exports.INSTRUCTION_INPUT_SCHEMA_REF = 'index_add#input';
+exports.INSTRUCTION_RECORD_SCHEMA_REF = CANONICAL.$id ?? 'instruction.schema.json';
+/**
+ * Build a tool-registry-friendly variant of INPUT_SCHEMA with a caller-supplied
+ * required[] minimum and a custom $id.
+ *
+ * Different MCP tool surfaces accept different "minimum required" shapes for
+ * the SAME underlying entry contract:
+ *
+ *   - index_add accepts { id, body } at minimum (handler defaults the rest)
+ *   - index_import requires { id, title, body, priority, audience, requirement }
+ *
+ * Both must still reject server-managed properties (additionalProperties:false +
+ * server-managed keys stripped) and use the same property definitions, enums,
+ * and patterns. This helper produces that variant from the canonical INPUT
+ * schema so the tool-discovery surface advertised over MCP cannot drift from
+ * the on-disk validation surface.
+ */
+function buildToolInputEntrySchema(opts) {
+    const cloned = deepClone(exports.INPUT_SCHEMA);
+    // Filter required[] to keys that actually exist as input properties. If a
+    // caller asks for a server-managed key we drop it (logic error in the
+    // caller, but never silently expose a server field as required input).
+    cloned.required = opts.required.filter((k) => exports.INPUT_KEYS.has(k) && !exports.SERVER_MANAGED_KEYS.has(k));
+    // Strip parent metadata that doesn't make sense embedded as a sub-schema.
+    // The tool-registry overlay (withDynamicInstructionBodyLimits) injects a
+    // per-compile unique $id so Ajv can both register the schema across
+    // re-compiles AND resolve internal "#/definitions/..." $refs.
+    const meta = cloned;
+    delete meta.$schema;
+    delete meta.title;
+    if (opts.schemaId) {
+        meta.$id = opts.schemaId;
+    }
+    else {
+        delete meta.$id;
+    }
+    return cloned;
+}

package/{schemas → dist/schemas}/json-schema/instruction-content-type.schema.json

@@ -5,12 +5,14 @@
     "ContentType": {
       "type": "string",
       "enum": [
+        "agent",
+        "skill",
         "instruction",
-        "template",
+        "prompt",
         "workflow",
-        "reference",
-        "example",
-        "agent"
+        "knowledge",
+        "template",
+        "integration"
       ]
     }
   }

package/{schemas → dist/schemas}/json-schema/instruction-instruction-entry.schema.json

@@ -198,12 +198,14 @@
     "ContentType": {
       "type": "string",
       "enum": [
+        "agent",
+        "skill",
         "instruction",
-        "template",
+        "prompt",
         "workflow",
-        "reference",
-        "example",
-        "agent"
+        "knowledge",
+        "template",
+        "integration"
       ]
     }
   }

package/dist/schemas/manifest.json

@@ -0,0 +1,78 @@
+{
+  "version": "1.28.19",
+  "generatedAt": "2026-05-11T01:35:27.991Z",
+  "trackedDir": "schemas",
+  "distDir": "dist/schemas",
+  "jsonSchemas": [
+    {
+      "type": "AudienceScope",
+      "source": "src/models/instruction.ts",
+      "file": "json-schema/instruction-audience-scope.schema.json"
+    },
+    {
+      "type": "ContentType",
+      "source": "src/models/instruction.ts",
+      "file": "json-schema/instruction-content-type.schema.json"
+    },
+    {
+      "type": "InstructionEntry",
+      "source": "src/models/instruction.ts",
+      "file": "json-schema/instruction-instruction-entry.schema.json"
+    },
+    {
+      "type": "RequirementLevel",
+      "source": "src/models/instruction.ts",
+      "file": "json-schema/instruction-requirement-level.schema.json"
+    },
+    {
+      "type": "PersistedAdminSession",
+      "source": "src/models/SessionPersistence.ts",
+      "file": "json-schema/SessionPersistence-persisted-admin-session.schema.json"
+    },
+    {
+      "type": "PersistedSessionHistoryEntry",
+      "source": "src/models/SessionPersistence.ts",
+      "file": "json-schema/SessionPersistence-persisted-session-history-entry.schema.json"
+    },
+    {
+      "type": "PersistedWebSocketConnection",
+      "source": "src/models/SessionPersistence.ts",
+      "file": "json-schema/SessionPersistence-persisted-web-socket-connection.schema.json"
+    },
+    {
+      "type": "SessionPersistenceConfig",
+      "source": "src/models/SessionPersistence.ts",
+      "file": "json-schema/SessionPersistence-session-persistence-config.schema.json"
+    },
+    {
+      "type": "SessionPersistenceData",
+      "source": "src/models/SessionPersistence.ts",
+      "file": "json-schema/SessionPersistence-session-persistence-data.schema.json"
+    },
+    {
+      "type": "SessionPersistenceManifest",
+      "source": "src/models/SessionPersistence.ts",
+      "file": "json-schema/SessionPersistence-session-persistence-manifest.schema.json"
+    },
+    {
+      "type": "SessionPersistenceMetadata",
+      "source": "src/models/SessionPersistence.ts",
+      "file": "json-schema/SessionPersistence-session-persistence-metadata.schema.json"
+    }
+  ],
+  "skippedJsonSchemas": [],
+  "codeModel": {
+    "file": "index-server.code-schema.json",
+    "sourceRoots": [
+      "src",
+      "scripts"
+    ],
+    "fileCount": 266,
+    "features": {
+      "jsdoc": true,
+      "lineNumbers": true,
+      "typeParameters": true,
+      "decorators": true
+    }
+  }
+}

package/dist/server/index-server.js

@@ -178,9 +178,15 @@ if (!process.listeners('uncaughtException').some(l => l.name === 'mcpGlobalGuard
     // are orphaned and should exit. The check uses process.kill(pid, 0) which on
     // Windows calls OpenProcess() -- it throws ESRCH if the process doesn't exist.
     // Skip when ppid is 0 or 1 (init / no parent) or when running interactively.
+    //
+    // Opt-out: INDEX_SERVER_DISABLE_PPID_WATCHDOG=1 disables the watchdog entirely.
+    // Required for dev sandbox launchers that intentionally spawn through a
+    // transient shell (e.g. `cmd /c start /B node ...`), where the recorded PPID
+    // is the cmd shell that exits immediately after spawning the node child.
     try {
+        const watchdogDisabled = (0, envUtils_1.getBooleanEnv)('INDEX_SERVER_DISABLE_PPID_WATCHDOG');
         const ppid = process.ppid;
-        if (ppid && ppid > 1) {
+        if (!watchdogDisabled && ppid && ppid > 1) {
             const PPID_CHECK_INTERVAL_MS = 30_000; // 30 seconds
             const ppidTimer = setInterval(() => {
                 try {

package/dist/services/bootstrapGating.js

@@ -22,11 +22,11 @@ const runtimeConfig_1 = require("../config/runtimeConfig");
  * Bootstrap / confirmation gating logic.
  * States:
  *  - reference mode (INDEX_SERVER_REFERENCE_MODE=1): index is read-only, all mutation blocked permanently
- *  - new workspace: only bootstrap seed instructions present (000-bootstrapper / 001-lifecycle-bootstrap) → require confirmation
+ *  - new workspace: only bootstrap seed instructions present (000-bootstrapper / 001-lifecycle-bootstrap / 002-content-model / 003-content-types) → require confirmation
  *  - existing workspace: any non-bootstrap instruction present OR confirmation file exists -> mutation allowed (unless explicitly forced read-only)
  *  - confirmed: confirmation file created after successful finalize → persists across restarts
  */
-const BOOTSTRAP_IDS = new Set(['000-bootstrapper', '001-lifecycle-bootstrap']);
+const BOOTSTRAP_IDS = new Set(['000-bootstrapper', '001-lifecycle-bootstrap', '002-content-model', '003-content-types']);
 const CONFIRM_FILE = 'bootstrap.confirmed.json';
 const PENDING_FILE = 'bootstrap.pending.json';
 let inMemoryPending = null;