@neuraloom/contracts 0.0.0-stage → 0.1.22

package/dist/schemas/orchestration-execution.d.ts

@@ -0,0 +1,158 @@
+import { z } from "zod";
+export declare const StepRetryOnSchema: z.ZodEnum<["transient", "none"]>;
+export declare const StepRetryPolicySchema: z.ZodObject<{
+    maxRetries: z.ZodNumber;
+    retryOn: z.ZodEnum<["transient", "none"]>;
+}, "strip", z.ZodTypeAny, {
+    maxRetries: number;
+    retryOn: "transient" | "none";
+}, {
+    maxRetries: number;
+    retryOn: "transient" | "none";
+}>;
+/** Stage status persisted on execution_tasks.metadata (Issue #1158). */
+export declare const ExecutionTaskStageStatusSchema: z.ZodEnum<["pending", "running", "complete", "failed"]>;
+/** Metadata shape for durable single-step stage pipelines on execution_tasks. */
+export declare const ExecutionTaskStageMetadataSchema: z.ZodObject<{
+    executionGranularity: z.ZodLiteral<"stage_pipeline">;
+    workflow_step_id: z.ZodString;
+    stage_keys: z.ZodArray<z.ZodString, "many">;
+    stage_key: z.ZodString;
+    stage_index: z.ZodNumber;
+    stage_status: z.ZodEnum<["pending", "running", "complete", "failed"]>;
+    current_stage: z.ZodNumber;
+    stage_attempts: z.ZodNumber;
+    stage_error_code: z.ZodOptional<z.ZodString>;
+    stage_error_message: z.ZodOptional<z.ZodString>;
+    stage_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    orchestration_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    previous_response_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    workflow_step_id: string;
+    executionGranularity: "stage_pipeline";
+    stage_keys: string[];
+    stage_key: string;
+    stage_index: number;
+    stage_status: "complete" | "running" | "failed" | "pending";
+    current_stage: number;
+    stage_attempts: number;
+    stage_error_code?: string | undefined;
+    stage_error_message?: string | undefined;
+    stage_metadata?: Record<string, unknown> | undefined;
+    orchestration_id?: string | null | undefined;
+    previous_response_id?: string | undefined;
+}, {
+    workflow_step_id: string;
+    executionGranularity: "stage_pipeline";
+    stage_keys: string[];
+    stage_key: string;
+    stage_index: number;
+    stage_status: "complete" | "running" | "failed" | "pending";
+    current_stage: number;
+    stage_attempts: number;
+    stage_error_code?: string | undefined;
+    stage_error_message?: string | undefined;
+    stage_metadata?: Record<string, unknown> | undefined;
+    orchestration_id?: string | null | undefined;
+    previous_response_id?: string | undefined;
+}>;
+export declare const DurableExecutionModeSchema: z.ZodEnum<["step_chain", "stage_pipeline"]>;
+/** POST /api/orchestration/run (durable 18-step parent run) */
+export declare const DurableOrchestrationStartSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    guardianThreshold: z.ZodDefault<z.ZodNumber>;
+    stopOnFailure: z.ZodDefault<z.ZodBoolean>;
+    enforceRules: z.ZodDefault<z.ZodBoolean>;
+    mode: z.ZodDefault<z.ZodEnum<["auto", "manual", "hybrid", "follow"]>>;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    mode: "auto" | "manual" | "hybrid" | "follow";
+    guardianThreshold: number;
+    stopOnFailure: boolean;
+    enforceRules: boolean;
+}, {
+    projectId: string;
+    mode?: "auto" | "manual" | "hybrid" | "follow" | undefined;
+    guardianThreshold?: number | undefined;
+    stopOnFailure?: boolean | undefined;
+    enforceRules?: boolean | undefined;
+}>;
+/** POST /api/orchestration/stage-run (durable single-step stage pipeline) */
+export declare const DurableStagePipelineStartSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    workflowStepId: z.ZodString;
+    guardianThreshold: z.ZodDefault<z.ZodNumber>;
+    stopOnFailure: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    guardianThreshold: number;
+    stopOnFailure: boolean;
+    workflowStepId: string;
+}, {
+    projectId: string;
+    workflowStepId: string;
+    guardianThreshold?: number | undefined;
+    stopOnFailure?: boolean | undefined;
+}>;
+/** Queued gateway response when Plan (or other stage pipelines) enqueue durable execution (#1159). */
+export declare const DurableStagePipelineQueuedResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    status: z.ZodLiteral<"queued">;
+    executionRunId: z.ZodString;
+    executionTaskId: z.ZodString;
+    stepKey: z.ZodString;
+    statusUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "queued";
+    ok: true;
+    executionRunId: string;
+    executionTaskId: string;
+    stepKey: string;
+    statusUrl: string;
+}, {
+    status: "queued";
+    ok: true;
+    executionRunId: string;
+    executionTaskId: string;
+    stepKey: string;
+    statusUrl: string;
+}>;
+export declare const DurableStagePipelineQueuedErrorSchema: z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    code: z.ZodString;
+    message: z.ZodString;
+    issues: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    ok: false;
+    issues?: unknown[] | undefined;
+}, {
+    code: string;
+    message: string;
+    ok: false;
+    issues?: unknown[] | undefined;
+}>;
+export declare const buildDurableRunStatusUrl: (runId: string, apiPrefix?: string) => string;
+/** POST /api/orchestration/continue (server-chained step or stage worker) */
+export declare const DurableOrchestrationContinueSchema: z.ZodEffects<z.ZodObject<{
+    runId: z.ZodString;
+    stepIndex: z.ZodOptional<z.ZodNumber>;
+    stageIndex: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    runId: string;
+    stepIndex?: number | undefined;
+    stageIndex?: number | undefined;
+}, {
+    runId: string;
+    stepIndex?: number | undefined;
+    stageIndex?: number | undefined;
+}>, {
+    runId: string;
+    stepIndex?: number | undefined;
+    stageIndex?: number | undefined;
+}, {
+    runId: string;
+    stepIndex?: number | undefined;
+    stageIndex?: number | undefined;
+}>;

package/dist/schemas/orchestration-execution.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurableOrchestrationContinueSchema = exports.buildDurableRunStatusUrl = exports.DurableStagePipelineQueuedErrorSchema = exports.DurableStagePipelineQueuedResponseSchema = exports.DurableStagePipelineStartSchema = exports.DurableOrchestrationStartSchema = exports.DurableExecutionModeSchema = exports.ExecutionTaskStageMetadataSchema = exports.ExecutionTaskStageStatusSchema = exports.StepRetryPolicySchema = exports.StepRetryOnSchema = void 0;
+const zod_1 = require("zod");
+const workflow_1 = require("../constants/workflow");
+const orchestration_execution_1 = require("../constants/orchestration-execution");
+exports.StepRetryOnSchema = zod_1.z.enum(["transient", "none"]);
+exports.StepRetryPolicySchema = zod_1.z.object({
+    maxRetries: zod_1.z.number().int().min(0).max(20),
+    retryOn: exports.StepRetryOnSchema,
+});
+/** Stage status persisted on execution_tasks.metadata (Issue #1158). */
+exports.ExecutionTaskStageStatusSchema = zod_1.z.enum([
+    "pending",
+    "running",
+    "complete",
+    "failed",
+]);
+/** Metadata shape for durable single-step stage pipelines on execution_tasks. */
+exports.ExecutionTaskStageMetadataSchema = zod_1.z.object({
+    executionGranularity: zod_1.z.literal("stage_pipeline"),
+    workflow_step_id: zod_1.z.string().min(1),
+    stage_keys: zod_1.z.array(zod_1.z.string().min(1)).min(1),
+    stage_key: zod_1.z.string().min(1),
+    stage_index: zod_1.z.number().int().min(0),
+    stage_status: exports.ExecutionTaskStageStatusSchema,
+    current_stage: zod_1.z.number().int().min(0),
+    stage_attempts: zod_1.z.number().int().min(0),
+    stage_error_code: zod_1.z.string().optional(),
+    stage_error_message: zod_1.z.string().optional(),
+    stage_metadata: zod_1.z.record(zod_1.z.unknown()).optional(),
+    orchestration_id: zod_1.z.string().uuid().nullable().optional(),
+    previous_response_id: zod_1.z.string().optional(),
+});
+exports.DurableExecutionModeSchema = zod_1.z.enum([
+    "step_chain",
+    "stage_pipeline",
+]);
+/** POST /api/orchestration/run (durable 18-step parent run) */
+exports.DurableOrchestrationStartSchema = zod_1.z.object({
+    projectId: zod_1.z.string().uuid(),
+    guardianThreshold: zod_1.z
+        .number()
+        .min(0)
+        .max(100)
+        .default(orchestration_execution_1.DEFAULT_ORCHESTRATION_GUARDIAN_THRESHOLD),
+    stopOnFailure: zod_1.z.boolean().default(false),
+    enforceRules: zod_1.z.boolean().default(true),
+    mode: zod_1.z.enum(["auto", "manual", "hybrid", "follow"]).default("auto"),
+});
+/** POST /api/orchestration/stage-run (durable single-step stage pipeline) */
+exports.DurableStagePipelineStartSchema = zod_1.z.object({
+    projectId: zod_1.z.string().uuid(),
+    workflowStepId: zod_1.z.string().min(1),
+    guardianThreshold: zod_1.z
+        .number()
+        .min(0)
+        .max(100)
+        .default(orchestration_execution_1.DEFAULT_ORCHESTRATION_GUARDIAN_THRESHOLD),
+    stopOnFailure: zod_1.z.boolean().default(true),
+});
+const stepMax = workflow_1.WORKFLOW_STEPS.length - 1;
+/** Queued gateway response when Plan (or other stage pipelines) enqueue durable execution (#1159). */
+exports.DurableStagePipelineQueuedResponseSchema = zod_1.z.object({
+    ok: zod_1.z.literal(true),
+    status: zod_1.z.literal("queued"),
+    executionRunId: zod_1.z.string().uuid(),
+    executionTaskId: zod_1.z.string().uuid(),
+    stepKey: zod_1.z.string().min(1),
+    statusUrl: zod_1.z.string().min(1),
+});
+exports.DurableStagePipelineQueuedErrorSchema = zod_1.z.object({
+    ok: zod_1.z.literal(false),
+    code: zod_1.z.string().min(1),
+    message: zod_1.z.string().min(1),
+    issues: zod_1.z.array(zod_1.z.unknown()).optional(),
+});
+const buildDurableRunStatusUrl = (runId, apiPrefix = "/api") => `${apiPrefix}/orchestration/run/${runId}/status`;
+exports.buildDurableRunStatusUrl = buildDurableRunStatusUrl;
+/** POST /api/orchestration/continue (server-chained step or stage worker) */
+exports.DurableOrchestrationContinueSchema = zod_1.z
+    .object({
+    runId: zod_1.z.string().uuid(),
+    stepIndex: zod_1.z.number().int().min(0).max(stepMax).optional(),
+    stageIndex: zod_1.z.number().int().min(0).optional(),
+})
+    .refine((value) => (value.stepIndex !== undefined && value.stageIndex === undefined) ||
+    (value.stepIndex === undefined && value.stageIndex !== undefined), { message: "Provide exactly one of stepIndex or stageIndex" });

package/dist/schemas/project-bmad-settings-patch.schema.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+/** PATCH /api/projects/[id]/settings — BMAD export controls + workflow execution mode (launch hub). */
+export declare const ProjectBmadSettingsPatchSchema: z.ZodObject<{
+    nl_kg_v2_enabled: z.ZodOptional<z.ZodBoolean>;
+    story_artifacts: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        auto_export: z.ZodOptional<z.ZodBoolean>;
+        formats: z.ZodOptional<z.ZodArray<z.ZodEnum<["markdown", "json"]>, "many">>;
+        store_in_bucket: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+        auto_export?: boolean | undefined;
+        formats?: ("json" | "markdown")[] | undefined;
+        store_in_bucket?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        auto_export?: boolean | undefined;
+        formats?: ("json" | "markdown")[] | undefined;
+        store_in_bucket?: boolean | undefined;
+    }>>;
+    export_limits: z.ZodOptional<z.ZodObject<{
+        max_per_hour: z.ZodOptional<z.ZodNumber>;
+        max_size_mb: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        max_per_hour?: number | undefined;
+        max_size_mb?: number | undefined;
+    }, {
+        max_per_hour?: number | undefined;
+        max_size_mb?: number | undefined;
+    }>>;
+    storage_usage_mb: z.ZodOptional<z.ZodNumber>;
+    workflowExecutionMode: z.ZodOptional<z.ZodEnum<["build-new", "audit-existing"]>>;
+    /** Gated per-project toggle: allow the Implement cron drainer to auto-merge green implement PRs. Default false. */
+    implementAutoMergeEnabled: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    workflowExecutionMode?: "build-new" | "audit-existing" | undefined;
+    nl_kg_v2_enabled?: boolean | undefined;
+    story_artifacts?: {
+        enabled?: boolean | undefined;
+        auto_export?: boolean | undefined;
+        formats?: ("json" | "markdown")[] | undefined;
+        store_in_bucket?: boolean | undefined;
+    } | undefined;
+    export_limits?: {
+        max_per_hour?: number | undefined;
+        max_size_mb?: number | undefined;
+    } | undefined;
+    storage_usage_mb?: number | undefined;
+    implementAutoMergeEnabled?: boolean | undefined;
+}, {
+    workflowExecutionMode?: "build-new" | "audit-existing" | undefined;
+    nl_kg_v2_enabled?: boolean | undefined;
+    story_artifacts?: {
+        enabled?: boolean | undefined;
+        auto_export?: boolean | undefined;
+        formats?: ("json" | "markdown")[] | undefined;
+        store_in_bucket?: boolean | undefined;
+    } | undefined;
+    export_limits?: {
+        max_per_hour?: number | undefined;
+        max_size_mb?: number | undefined;
+    } | undefined;
+    storage_usage_mb?: number | undefined;
+    implementAutoMergeEnabled?: boolean | undefined;
+}>;
+export type ProjectBmadSettingsPatch = z.infer<typeof ProjectBmadSettingsPatchSchema>;

package/dist/schemas/project-bmad-settings-patch.schema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectBmadSettingsPatchSchema = void 0;
+const zod_1 = require("zod");
+const workflow_execution_mode_schema_1 = require("./ai/workflow-execution-mode.schema");
+/** PATCH /api/projects/[id]/settings — BMAD export controls + workflow execution mode (launch hub). */
+exports.ProjectBmadSettingsPatchSchema = zod_1.z
+    .object({
+    nl_kg_v2_enabled: zod_1.z.boolean().optional(),
+    story_artifacts: zod_1.z
+        .object({
+        enabled: zod_1.z.boolean().optional(),
+        auto_export: zod_1.z.boolean().optional(),
+        formats: zod_1.z.array(zod_1.z.enum(["markdown", "json"])).optional(),
+        store_in_bucket: zod_1.z.boolean().optional(),
+    })
+        .optional(),
+    export_limits: zod_1.z
+        .object({
+        max_per_hour: zod_1.z.number().min(1).max(100).optional(),
+        max_size_mb: zod_1.z.number().min(1).max(1000).optional(),
+    })
+        .optional(),
+    storage_usage_mb: zod_1.z.number().optional(),
+    workflowExecutionMode: workflow_execution_mode_schema_1.WorkflowExecutionModeSchema.optional(),
+    /** Gated per-project toggle: allow the Implement cron drainer to auto-merge green implement PRs. Default false. */
+    implementAutoMergeEnabled: zod_1.z.boolean().optional(),
+})
+    .strict();

package/dist/schemas/project-kind.schema.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Zod schemas for the Universal Cognitive Workflow kind taxonomy.
+ * All types validated here are defined in types/project-kind.ts.
+ */
+import { z } from 'zod';
+export declare const ProjectKindSchema: z.ZodEnum<["software", "fiction", "nonfiction", "research", "documentary", "simulation", "educational", "mixed", "film"]>;
+export declare const WorkflowStepKindSchema: z.ZodEnum<["intent", "structure", "ontology", "interaction", "experience", "tasks", "generation", "review"]>;
+export declare const StepSemanticConfigSchema: z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodString;
+    promptHint: z.ZodString;
+    gateChecks: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    label: string;
+    promptHint: string;
+    gateChecks: string[];
+}, {
+    description: string;
+    label: string;
+    promptHint: string;
+    gateChecks: string[];
+}>;
+export declare const WorkflowStepSemanticsSchema: z.ZodRecord<z.ZodEnum<["software", "fiction", "nonfiction", "research", "documentary", "simulation", "educational", "mixed", "film"]>, z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodString;
+    promptHint: z.ZodString;
+    gateChecks: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    label: string;
+    promptHint: string;
+    gateChecks: string[];
+}, {
+    description: string;
+    label: string;
+    promptHint: string;
+    gateChecks: string[];
+}>>;
+export declare const FictionArtifactKindSchema: z.ZodEnum<["chapter", "scene", "lore_entry", "faction", "symbol", "timeline_event", "character_arc", "dream_sequence", "ideology", "prophecy", "institution", "emotional_turn", "world_bible", "narrative_structure", "ontology_system", "relational_graph"]>;
+export declare const NonfictionArtifactKindSchema: z.ZodEnum<["claim", "source", "counterclaim", "thesis", "evidence_cluster", "timeline", "interview", "citation_group", "documentary_segment", "source_registry", "evidence_graph"]>;
+export declare const SoftwareArtifactKindSchema: z.ZodEnum<["component", "schema", "api_route", "migration", "test", "config"]>;
+export declare const ArtifactKindSchema: z.ZodUnion<[z.ZodEnum<["chapter", "scene", "lore_entry", "faction", "symbol", "timeline_event", "character_arc", "dream_sequence", "ideology", "prophecy", "institution", "emotional_turn", "world_bible", "narrative_structure", "ontology_system", "relational_graph"]>, z.ZodEnum<["claim", "source", "counterclaim", "thesis", "evidence_cluster", "timeline", "interview", "citation_group", "documentary_segment", "source_registry", "evidence_graph"]>, z.ZodEnum<["component", "schema", "api_route", "migration", "test", "config"]>]>;
+export declare const GateCheckIdSchema: z.ZodString;
+export declare const KindGateSpecSchema: z.ZodObject<{
+    checks: z.ZodArray<z.ZodString, "many">;
+    required: z.ZodArray<z.ZodString, "many">;
+    optional: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    required: string[];
+    checks: string[];
+    optional: string[];
+}, {
+    required: string[];
+    checks: string[];
+    optional: string[];
+}>;
+export declare const ContextualGateConfigSchema: z.ZodRecord<z.ZodEnum<["software", "fiction", "nonfiction", "research", "documentary", "simulation", "educational", "mixed", "film"]>, z.ZodObject<{
+    checks: z.ZodArray<z.ZodString, "many">;
+    required: z.ZodArray<z.ZodString, "many">;
+    optional: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    required: string[];
+    checks: string[];
+    optional: string[];
+}, {
+    required: string[];
+    checks: string[];
+    optional: string[];
+}>>;

package/dist/schemas/project-kind.schema.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Zod schemas for the Universal Cognitive Workflow kind taxonomy.
+ * All types validated here are defined in types/project-kind.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextualGateConfigSchema = exports.KindGateSpecSchema = exports.GateCheckIdSchema = exports.ArtifactKindSchema = exports.SoftwareArtifactKindSchema = exports.NonfictionArtifactKindSchema = exports.FictionArtifactKindSchema = exports.WorkflowStepSemanticsSchema = exports.StepSemanticConfigSchema = exports.WorkflowStepKindSchema = exports.ProjectKindSchema = void 0;
+const zod_1 = require("zod");
+const project_kind_1 = require("../types/project-kind");
+// ─── Project Kind ─────────────────────────────────────────────────────────────
+exports.ProjectKindSchema = zod_1.z.enum(project_kind_1.PROJECT_KINDS);
+// ─── Workflow Step Kind ───────────────────────────────────────────────────────
+exports.WorkflowStepKindSchema = zod_1.z.enum(project_kind_1.WORKFLOW_STEP_KINDS);
+// ─── Step Semantic Config ─────────────────────────────────────────────────────
+exports.StepSemanticConfigSchema = zod_1.z.object({
+    label: zod_1.z.string().min(1),
+    description: zod_1.z.string().min(1),
+    promptHint: zod_1.z.string(),
+    gateChecks: zod_1.z.array(zod_1.z.string()),
+});
+exports.WorkflowStepSemanticsSchema = zod_1.z.record(exports.ProjectKindSchema, exports.StepSemanticConfigSchema);
+// ─── Artifact Kinds ───────────────────────────────────────────────────────────
+exports.FictionArtifactKindSchema = zod_1.z.enum(project_kind_1.FICTION_ARTIFACT_KINDS);
+exports.NonfictionArtifactKindSchema = zod_1.z.enum(project_kind_1.NONFICTION_ARTIFACT_KINDS);
+exports.SoftwareArtifactKindSchema = zod_1.z.enum(project_kind_1.SOFTWARE_ARTIFACT_KINDS);
+exports.ArtifactKindSchema = zod_1.z.union([
+    exports.FictionArtifactKindSchema,
+    exports.NonfictionArtifactKindSchema,
+    exports.SoftwareArtifactKindSchema,
+]);
+// ─── Contextual Gate Config ───────────────────────────────────────────────────
+exports.GateCheckIdSchema = zod_1.z.string().min(1);
+exports.KindGateSpecSchema = zod_1.z.object({
+    checks: zod_1.z.array(exports.GateCheckIdSchema),
+    required: zod_1.z.array(exports.GateCheckIdSchema),
+    optional: zod_1.z.array(exports.GateCheckIdSchema),
+});
+exports.ContextualGateConfigSchema = zod_1.z.record(exports.ProjectKindSchema, exports.KindGateSpecSchema);

package/dist/schemas/project-team.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Project team (project_team table) — request/response SSOT
+ */
+import { z } from "zod";
+export declare const TeamInviteRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+}, {
+    email: string;
+}>;
+export type TeamInviteRequest = z.infer<typeof TeamInviteRequestSchema>;
+/** Row shape returned from Supabase `project_team` inserts/selects */
+export declare const ProjectTeamMemberSchema: z.ZodObject<{
+    id: z.ZodString;
+    project_id: z.ZodString;
+    user_id: z.ZodString;
+    role: z.ZodEnum<["owner", "admin", "member", "client"]>;
+    created_at: z.ZodString;
+    added_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    created_at: string;
+    project_id: string;
+    role: "admin" | "member" | "owner" | "client";
+    user_id: string;
+    added_by?: string | null | undefined;
+}, {
+    id: string;
+    created_at: string;
+    project_id: string;
+    role: "admin" | "member" | "owner" | "client";
+    user_id: string;
+    added_by?: string | null | undefined;
+}>;
+export type ProjectTeamMember = z.infer<typeof ProjectTeamMemberSchema>;
+export declare const ProjectTeamRoleSchema: z.ZodEnum<["owner", "admin", "member", "client"]>;
+export type ProjectTeamRole = z.infer<typeof ProjectTeamRoleSchema>;
+export type ProjectBriefWritePermission = {
+    canEdit: boolean;
+    reason: string | null;
+};
+/** Mirrors PUT/PATCH authorization on /api/projects/[id] for brief edits. */
+export declare function resolveProjectBriefWritePermission(input: {
+    ownerId: string | null | undefined;
+    userId: string | null | undefined;
+    teamRole: ProjectTeamRole | null | undefined;
+}): ProjectBriefWritePermission;

package/dist/schemas/project-team.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Project team (project_team table) — request/response SSOT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectTeamRoleSchema = exports.ProjectTeamMemberSchema = exports.TeamInviteRequestSchema = void 0;
+exports.resolveProjectBriefWritePermission = resolveProjectBriefWritePermission;
+const zod_1 = require("zod");
+const Uuid = zod_1.z.string().uuid();
+exports.TeamInviteRequestSchema = zod_1.z.object({
+    email: zod_1.z.string().email(),
+});
+/** Row shape returned from Supabase `project_team` inserts/selects */
+exports.ProjectTeamMemberSchema = zod_1.z.object({
+    id: Uuid,
+    project_id: Uuid,
+    user_id: Uuid,
+    role: zod_1.z.enum(["owner", "admin", "member", "client"]),
+    created_at: zod_1.z.string(),
+    added_by: Uuid.nullable().optional(),
+});
+exports.ProjectTeamRoleSchema = exports.ProjectTeamMemberSchema.shape.role;
+const PROJECT_BRIEF_WRITE_ROLES = new Set([
+    "owner",
+    "admin",
+    "member",
+]);
+/** Mirrors PUT/PATCH authorization on /api/projects/[id] for brief edits. */
+function resolveProjectBriefWritePermission(input) {
+    const ownerId = input.ownerId ?? "";
+    const userId = input.userId ?? "";
+    if (ownerId.length === 0 || userId.length === 0) {
+        return { canEdit: false, reason: null };
+    }
+    if (ownerId === userId) {
+        return { canEdit: true, reason: null };
+    }
+    const role = input.teamRole;
+    if (role !== undefined && role !== null && PROJECT_BRIEF_WRITE_ROLES.has(role)) {
+        return { canEdit: true, reason: null };
+    }
+    if (role === "client") {
+        return {
+            canEdit: false,
+            reason: "You have read-only access to this project brief.",
+        };
+    }
+    return {
+        canEdit: false,
+        reason: "You do not have permission to edit this project brief.",
+    };
+}

package/dist/schemas/projects/nl-kg-v2-enabled.schema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * project_settings.settings key — KG v2 typed overlays (kg_edge_type, kg_stable_key, kg_layer)
+ * for graph query + review coverage. Issue #765.
+ *
+ * PATCH field `nl_kg_v2_enabled` is validated by `ProjectBmadSettingsPatchSchema` (project-bmad-settings-patch.schema.ts).
+ */
+import type { Json } from "../../types";
+export declare const NL_KG_V2_ENABLED_SETTINGS_KEY: "nl_kg_v2_enabled";
+/** Default false; only explicit `true` enables v2 semantics (server-authoritative). */
+export declare function parseNlKgV2EnabledFromProjectSettings(settings: Json): boolean;

package/dist/schemas/projects/nl-kg-v2-enabled.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NL_KG_V2_ENABLED_SETTINGS_KEY = void 0;
+exports.parseNlKgV2EnabledFromProjectSettings = parseNlKgV2EnabledFromProjectSettings;
+exports.NL_KG_V2_ENABLED_SETTINGS_KEY = "nl_kg_v2_enabled";
+/** Default false; only explicit `true` enables v2 semantics (server-authoritative). */
+function parseNlKgV2EnabledFromProjectSettings(settings) {
+    if (settings === null || typeof settings !== "object") {
+        return false;
+    }
+    if (Array.isArray(settings)) {
+        return false;
+    }
+    const raw = settings[exports.NL_KG_V2_ENABLED_SETTINGS_KEY];
+    return raw === true;
+}

package/dist/schemas/provider-sentinel/cleanup-manifest.schema.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Provider Sentinel cleanup manifest — records created rows for safe teardown.
+ */
+import { z } from 'zod';
+export declare const CleanupManifestRowSchema: z.ZodObject<{
+    table: z.ZodString;
+    id: z.ZodString;
+    cleanupMode: z.ZodEnum<["hard_delete", "retain_mark"]>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    table: string;
+    cleanupMode: "hard_delete" | "retain_mark";
+}, {
+    id: string;
+    table: string;
+    cleanupMode: "hard_delete" | "retain_mark";
+}>;
+export type CleanupManifestRow = z.infer<typeof CleanupManifestRowSchema>;
+export declare const CleanupManifestStorageObjectSchema: z.ZodObject<{
+    bucket: z.ZodString;
+    path: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    bucket: string;
+}, {
+    path: string;
+    bucket: string;
+}>;
+export type CleanupManifestStorageObject = z.infer<typeof CleanupManifestStorageObjectSchema>;
+export declare const CleanupManifestSchema: z.ZodObject<{
+    sentinelRunId: z.ZodString;
+    rows: z.ZodArray<z.ZodObject<{
+        table: z.ZodString;
+        id: z.ZodString;
+        cleanupMode: z.ZodEnum<["hard_delete", "retain_mark"]>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        table: string;
+        cleanupMode: "hard_delete" | "retain_mark";
+    }, {
+        id: string;
+        table: string;
+        cleanupMode: "hard_delete" | "retain_mark";
+    }>, "many">;
+    storageObjects: z.ZodArray<z.ZodObject<{
+        bucket: z.ZodString;
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        bucket: string;
+    }, {
+        path: string;
+        bucket: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    rows: {
+        id: string;
+        table: string;
+        cleanupMode: "hard_delete" | "retain_mark";
+    }[];
+    sentinelRunId: string;
+    storageObjects: {
+        path: string;
+        bucket: string;
+    }[];
+}, {
+    rows: {
+        id: string;
+        table: string;
+        cleanupMode: "hard_delete" | "retain_mark";
+    }[];
+    sentinelRunId: string;
+    storageObjects: {
+        path: string;
+        bucket: string;
+    }[];
+}>;
+export type CleanupManifest = z.infer<typeof CleanupManifestSchema>;