@neuraloom/contracts 0.0.0-stage → 0.1.23

package/dist/workflow/evaluate-existing-codebase-readiness.d.ts

@@ -0,0 +1,28 @@
+import type { WorkflowExecutionMode } from '../schemas/ai/workflow-execution-mode.schema';
+import { type ExistingCodebaseContext, type ExistingCodebaseReadiness, type ExistingCodebaseStepArea, type ExistingCodebaseStepReadiness } from '../schemas/workflow/existing-codebase-context.schema';
+import type { CodeRealityAvailability } from '../schemas/workflow/code-reality-read-model.schema';
+export type ExistingCodebaseContextInputs = {
+    mode: WorkflowExecutionMode | null;
+    repository: ExistingCodebaseContext['repository'];
+    repoIntelSnapshot: ExistingCodebaseContext['repoIntelSnapshot'];
+    repoPolicySnapshot: ExistingCodebaseContext['repoPolicySnapshot'];
+    findingsRegister: ExistingCodebaseContext['findingsRegister'];
+    existingCapabilityClassification: ExistingCodebaseContext['existingCapabilityClassification'];
+    canonicalizationDecision: ExistingCodebaseContext['canonicalizationDecision'];
+    commitSha: string | null;
+    scanStatus: string | null;
+    codeRealityAvailability?: CodeRealityAvailability;
+};
+export type ExistingCodebaseWorkflowStepReadiness = {
+    stepId: string;
+    area: ExistingCodebaseStepArea | null;
+    readiness: ExistingCodebaseReadiness;
+    missingReasons: string[];
+    blockedMessage: string;
+};
+export declare function buildExistingCodebaseContext(input: ExistingCodebaseContextInputs): ExistingCodebaseContext;
+export declare function formatExistingCodebasePromptBlock(ctx: ExistingCodebaseContext, area: ExistingCodebaseStepArea): string;
+export declare function evaluateExistingCodebaseStepReadiness(ctx: ExistingCodebaseContext, area: ExistingCodebaseStepArea): ExistingCodebaseStepReadiness;
+export declare function existingCodebaseStepBlockedMessage(step: ExistingCodebaseStepReadiness): string;
+export declare function existingCodebaseWorkflowStepBlockedMessage(step: ExistingCodebaseWorkflowStepReadiness): string;
+export declare function evaluateExistingCodebaseWorkflowStepReadiness(ctx: ExistingCodebaseContext, stepId: string): ExistingCodebaseWorkflowStepReadiness;

package/dist/workflow/evaluate-existing-codebase-readiness.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildExistingCodebaseContext = buildExistingCodebaseContext;
+exports.formatExistingCodebasePromptBlock = formatExistingCodebasePromptBlock;
+exports.evaluateExistingCodebaseStepReadiness = evaluateExistingCodebaseStepReadiness;
+exports.existingCodebaseStepBlockedMessage = existingCodebaseStepBlockedMessage;
+exports.existingCodebaseWorkflowStepBlockedMessage = existingCodebaseWorkflowStepBlockedMessage;
+exports.evaluateExistingCodebaseWorkflowStepReadiness = evaluateExistingCodebaseWorkflowStepReadiness;
+const existing_codebase_step_area_map_1 = require("./existing-codebase-step-area-map");
+const normalize_workflow_execution_mode_1 = require("./normalize-workflow-execution-mode");
+const is_repository_scan_complete_1 = require("./is-repository-scan-complete");
+const INGEST_GATE_STEPS = new Set(['specify', 'plan']);
+const DESIGN_GRAPH_STEPS = new Set(['specify', 'plan', 'schema', 'api', 'ui']);
+const SLICE_STEP_KEYS = {
+    schema: 'schema',
+    api: 'api',
+    ui: 'ui',
+    constitution: 'governance',
+};
+function baseContext(input) {
+    const applies = (0, normalize_workflow_execution_mode_1.isAuditLikeExecutionMode)(input.mode);
+    if (!applies) {
+        return {
+            mode: input.mode,
+            applies: false,
+            readiness: 'not_applicable',
+            missingReasons: [],
+            repository: input.repository,
+            repoIntelSnapshot: input.repoIntelSnapshot,
+            repoPolicySnapshot: input.repoPolicySnapshot,
+            findingsRegister: input.findingsRegister,
+            existingCapabilityClassification: input.existingCapabilityClassification,
+            canonicalizationDecision: input.canonicalizationDecision,
+            commitSha: input.commitSha,
+            scanStatus: input.scanStatus,
+        };
+    }
+    const missing = [];
+    if (!input.repository.linked) {
+        missing.push('linked_repository_missing');
+    }
+    if (input.repoIntelSnapshot === null) {
+        missing.push('accepted_repo_intel_snapshot_missing');
+    }
+    if (input.repoPolicySnapshot === null) {
+        missing.push('accepted_repo_policy_snapshot_missing');
+    }
+    if (!(0, is_repository_scan_complete_1.isRepositoryScanComplete)({
+        repository: input.repository,
+        scanStatus: input.scanStatus,
+        ...(input.codeRealityAvailability?.semanticMapped === false
+            ? { semanticMapped: false }
+            : {}),
+    })) {
+        missing.push('repo_scan_not_complete');
+    }
+    if (input.codeRealityAvailability?.semanticMapped === false) {
+        missing.push('code_reality_semantic_index_not_mapped');
+    }
+    let readiness = 'ready';
+    if (missing.includes('accepted_repo_intel_snapshot_missing') ||
+        missing.includes('accepted_repo_policy_snapshot_missing')) {
+        readiness = 'blocked';
+    }
+    else if (missing.length > 0) {
+        readiness = 'degraded';
+    }
+    return {
+        mode: input.mode,
+        applies: true,
+        readiness,
+        missingReasons: missing,
+        repository: input.repository,
+        repoIntelSnapshot: input.repoIntelSnapshot,
+        repoPolicySnapshot: input.repoPolicySnapshot,
+        findingsRegister: input.findingsRegister,
+        existingCapabilityClassification: input.existingCapabilityClassification,
+        canonicalizationDecision: input.canonicalizationDecision,
+        commitSha: input.commitSha,
+        scanStatus: input.scanStatus,
+        ...(input.codeRealityAvailability !== undefined
+            ? { codeRealityAvailability: input.codeRealityAvailability }
+            : {}),
+    };
+}
+function buildExistingCodebaseContext(input) {
+    return baseContext(input);
+}
+function codeRealitySnapshotMissing(ctx) {
+    const availability = ctx.codeRealityAvailability;
+    if (availability === undefined || !availability.applicable) {
+        return false;
+    }
+    return (availability.snapshotArtifactId === null ||
+        availability.missingEvidenceWarnings.includes('code_reality_snapshot_missing'));
+}
+function sliceCountForStep(ctx, stepId) {
+    const sliceKey = SLICE_STEP_KEYS[stepId];
+    if (sliceKey === undefined) {
+        return null;
+    }
+    const counts = ctx.codeRealityAvailability?.sliceInventoryCounts;
+    if (counts === undefined) {
+        return null;
+    }
+    const value = counts[sliceKey];
+    return value !== undefined ? value : null;
+}
+function escalateReadiness(current, next) {
+    if (current === 'blocked' || next === 'blocked') {
+        return 'blocked';
+    }
+    if (current === 'degraded' || next === 'degraded') {
+        return 'degraded';
+    }
+    if (current === 'ready' || next === 'ready') {
+        return 'ready';
+    }
+    return 'not_applicable';
+}
+function designReadiness(ctx) {
+    if (!ctx.applies) {
+        return 'not_applicable';
+    }
+    if (ctx.repoIntelSnapshot === null) {
+        return 'blocked';
+    }
+    if (ctx.readiness === 'blocked') {
+        return 'blocked';
+    }
+    if (ctx.findingsRegister === null || ctx.existingCapabilityClassification === null) {
+        return 'degraded';
+    }
+    return 'ready';
+}
+function governanceReadiness(ctx) {
+    if (!ctx.applies) {
+        return 'not_applicable';
+    }
+    if (ctx.repoPolicySnapshot === null) {
+        return 'blocked';
+    }
+    if (ctx.repoIntelSnapshot === null) {
+        return 'degraded';
+    }
+    return ctx.readiness === 'blocked' ? 'blocked' : 'ready';
+}
+function buildReadiness(ctx) {
+    if (!ctx.applies) {
+        return 'not_applicable';
+    }
+    if (ctx.repoIntelSnapshot === null || ctx.repoPolicySnapshot === null) {
+        return 'blocked';
+    }
+    if (ctx.findingsRegister === null || ctx.existingCapabilityClassification === null) {
+        return 'degraded';
+    }
+    return 'ready';
+}
+function shipReadiness(ctx) {
+    if (!ctx.applies) {
+        return 'not_applicable';
+    }
+    if (ctx.repoIntelSnapshot === null || ctx.repoPolicySnapshot === null) {
+        return 'blocked';
+    }
+    if (!ctx.repository.linked) {
+        return 'blocked';
+    }
+    if (ctx.findingsRegister === null) {
+        return 'degraded';
+    }
+    return 'ready';
+}
+function readinessForArea(ctx, area) {
+    switch (area) {
+        case 'design':
+            return designReadiness(ctx);
+        case 'governance':
+            return governanceReadiness(ctx);
+        case 'build':
+            return buildReadiness(ctx);
+        case 'ship':
+            return shipReadiness(ctx);
+        default: {
+            const _exhaustive = area;
+            return _exhaustive;
+        }
+    }
+}
+function missingForArea(ctx, area, readiness) {
+    if (readiness === 'not_applicable') {
+        return [];
+    }
+    const reasons = [...ctx.missingReasons];
+    if (area === 'design' && ctx.repoIntelSnapshot === null) {
+        reasons.push('design_requires_repo_intel_snapshot');
+    }
+    if (area === 'governance' && ctx.repoPolicySnapshot === null) {
+        reasons.push('governance_requires_repo_policy_snapshot');
+    }
+    if (area === 'build') {
+        if (ctx.findingsRegister === null) {
+            reasons.push('build_requires_findings_register');
+        }
+        if (ctx.existingCapabilityClassification === null) {
+            reasons.push('build_requires_capability_classification');
+        }
+    }
+    if (area === 'ship' && ctx.findingsRegister === null) {
+        reasons.push('ship_requires_findings_and_lineage');
+    }
+    return [...new Set(reasons)];
+}
+function formatExistingCodebasePromptBlock(ctx, area) {
+    if (!ctx.applies) {
+        return '';
+    }
+    const lines = [
+        `EXISTING-CODEBASE MODE (${area}): Frame all outputs as repair, consolidation, extension, or deletion against the ingested repo — not greenfield architecture.`,
+    ];
+    if (ctx.repoIntelSnapshot !== null) {
+        lines.push(`repoIntelSnapshot artifactId=${ctx.repoIntelSnapshot.artifactId}`);
+    }
+    if (ctx.repoPolicySnapshot !== null) {
+        lines.push(`repoPolicySnapshot artifactId=${ctx.repoPolicySnapshot.artifactId}`);
+    }
+    if (ctx.findingsRegister !== null) {
+        lines.push(`findingsRegister artifactId=${ctx.findingsRegister.artifactId}`);
+    }
+    if (ctx.existingCapabilityClassification !== null) {
+        lines.push(`existingCapabilityClassification artifactId=${ctx.existingCapabilityClassification.artifactId}`);
+    }
+    if (ctx.canonicalizationDecision !== null) {
+        lines.push(`canonicalizationDecision artifactId=${ctx.canonicalizationDecision.artifactId}`);
+    }
+    if (ctx.commitSha !== null) {
+        lines.push(`indexedCommitSha=${ctx.commitSha}`);
+    }
+    if (ctx.repository.repositoryUrl !== null) {
+        lines.push(`linkedRepo=${ctx.repository.repositoryUrl}`);
+    }
+    if (ctx.scanStatus !== null) {
+        lines.push(`scanStatus=${ctx.scanStatus}`);
+    }
+    return lines.join('\n');
+}
+function evaluateExistingCodebaseStepReadiness(ctx, area) {
+    const readiness = readinessForArea(ctx, area);
+    const missingReasons = missingForArea(ctx, area, readiness);
+    const promptBlock = readiness === 'not_applicable' ? '' : formatExistingCodebasePromptBlock(ctx, area);
+    return {
+        area,
+        readiness,
+        missingReasons,
+        promptBlock,
+        ...(ctx.codeRealityAvailability !== undefined
+            ? { codeRealityAvailability: ctx.codeRealityAvailability }
+            : {}),
+    };
+}
+function existingCodebaseStepBlockedMessage(step) {
+    if (step.readiness !== 'blocked') {
+        return '';
+    }
+    const detail = step.missingReasons.length > 0 ? step.missingReasons.join(', ') : 'missing_ingest_context';
+    return `Existing-codebase ${step.area} step blocked: ${detail}. Complete Ingest (repo scan + accepted intel/policy snapshots) before continuing.`;
+}
+function existingCodebaseWorkflowStepBlockedMessage(step) {
+    if (step.readiness !== 'blocked') {
+        return '';
+    }
+    const detail = step.missingReasons.length > 0 ? step.missingReasons.join(', ') : 'missing_graph_or_ingest_context';
+    const label = step.area ?? step.stepId;
+    return `Existing-codebase ${label} step blocked: ${detail}.`;
+}
+function evaluateExistingCodebaseWorkflowStepReadiness(ctx, stepId) {
+    const area = (0, existing_codebase_step_area_map_1.resolveExistingCodebaseArea)(stepId);
+    if (!ctx.applies || area === null) {
+        return {
+            stepId,
+            area,
+            readiness: 'not_applicable',
+            missingReasons: [],
+            blockedMessage: '',
+        };
+    }
+    const areaStep = evaluateExistingCodebaseStepReadiness(ctx, area);
+    let readiness = areaStep.readiness;
+    const missingReasons = [...areaStep.missingReasons];
+    if (INGEST_GATE_STEPS.has(stepId) && ctx.readiness !== 'ready') {
+        readiness = 'blocked';
+        for (const reason of ctx.missingReasons) {
+            if (!missingReasons.includes(reason)) {
+                missingReasons.push(reason);
+            }
+        }
+    }
+    if (codeRealitySnapshotMissing(ctx) && DESIGN_GRAPH_STEPS.has(stepId)) {
+        missingReasons.push('code_reality_snapshot_missing');
+        const graphSeverity = stepId === 'specify' || stepId === 'plan' ? 'blocked' : 'degraded';
+        readiness = escalateReadiness(readiness, graphSeverity);
+    }
+    const sliceCount = sliceCountForStep(ctx, stepId);
+    if (sliceCount !== null && codeRealitySnapshotMissing(ctx) === false) {
+        if (sliceCount === 0) {
+            missingReasons.push(`code_reality_${stepId}_slice_empty`);
+            readiness = escalateReadiness(readiness, 'degraded');
+        }
+    }
+    if ((stepId === 'tasks' || stepId === 'implement') && ctx.findingsRegister === null) {
+        missingReasons.push('build_requires_findings_register');
+        readiness = escalateReadiness(readiness, 'degraded');
+    }
+    if (stepId === 'review' && ctx.findingsRegister === null) {
+        missingReasons.push('ship_requires_findings_and_lineage');
+        readiness = escalateReadiness(readiness, 'degraded');
+    }
+    const uniqueReasons = [...new Set(missingReasons)];
+    const result = {
+        stepId,
+        area,
+        readiness,
+        missingReasons: uniqueReasons,
+        blockedMessage: '',
+    };
+    result.blockedMessage = existingCodebaseWorkflowStepBlockedMessage(result);
+    return result;
+}

package/dist/workflow/evaluate-ingest-gate.d.ts

@@ -0,0 +1,11 @@
+import type { WorkflowExecutionMode } from '../schemas/ai/workflow-execution-mode.schema';
+import { type IngestGateStatus } from '../schemas/workflow/ingest-gate.schema';
+export type { IngestGateStatus } from '../schemas/workflow/ingest-gate.schema';
+export { IngestGateStatusSchema } from '../schemas/workflow/ingest-gate.schema';
+/** Accepts real Supabase clients; query chain is cast internally (no @supabase/supabase-js in contracts). */
+export type IngestGateSupabaseClient = {
+    from: (relation: string) => object;
+};
+type IngestGateMode = WorkflowExecutionMode | null;
+export declare function ingestGateAllowsProgress(status: IngestGateStatus): boolean;
+export declare function evaluateIngestGate(supabase: IngestGateSupabaseClient, projectId: string, mode: IngestGateMode): Promise<IngestGateStatus>;

package/dist/workflow/evaluate-ingest-gate.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IngestGateStatusSchema = void 0;
+exports.ingestGateAllowsProgress = ingestGateAllowsProgress;
+exports.evaluateIngestGate = evaluateIngestGate;
+const normalize_workflow_execution_mode_1 = require("./normalize-workflow-execution-mode");
+const workflow_artifacts_schema_1 = require("../schemas/ai/workflow-artifacts.schema");
+const code_reality_artifacts_schema_1 = require("../schemas/workflow/code-reality-artifacts.schema");
+const is_code_reality_semantically_mapped_1 = require("./is-code-reality-semantically-mapped");
+const ingest_gate_schema_1 = require("../schemas/workflow/ingest-gate.schema");
+var ingest_gate_schema_2 = require("../schemas/workflow/ingest-gate.schema");
+Object.defineProperty(exports, "IngestGateStatusSchema", { enumerable: true, get: function () { return ingest_gate_schema_2.IngestGateStatusSchema; } });
+function ingestTable(client, table) {
+    return client.from(table);
+}
+function isPassedStatus(status) {
+    return status === 'passed' || status === 'passed_with_warnings';
+}
+function ingestGateAllowsProgress(status) {
+    return isPassedStatus(status.status);
+}
+async function resolveWorkflowExecutionMode(supabase, projectId, mode) {
+    if (mode !== null) {
+        return mode;
+    }
+    const { data, error } = await ingestTable(supabase, 'project_settings')
+        .select('settings')
+        .eq('project_id', projectId)
+        .maybeSingle();
+    if (error !== null || data === null || Array.isArray(data)) {
+        return null;
+    }
+    const settings = data.settings;
+    if (settings === null || settings === undefined) {
+        return null;
+    }
+    return (0, normalize_workflow_execution_mode_1.normalizeWorkflowExecutionMode)(settings.workflowExecutionMode);
+}
+async function loadRepoLinked(supabase, projectId) {
+    const { data, error } = await ingestTable(supabase, 'git_repositories')
+        .select('repository_url, last_scanned_at, sync_status')
+        .eq('project_id', projectId)
+        .not('repository_url', 'is', null)
+        .order('updated_at', { ascending: false })
+        .limit(5);
+    if (error !== null || data === null) {
+        return { repoLinked: false, treeScanned: false };
+    }
+    const rows = Array.isArray(data) ? data : [];
+    if (rows.length === 0) {
+        return { repoLinked: false, treeScanned: false };
+    }
+    const active = rows.find((row) => row.sync_status !== 'disconnected');
+    const repoLinked = active !== undefined;
+    const treeScanned = repoLinked &&
+        typeof active?.last_scanned_at === 'string' &&
+        active.last_scanned_at.length > 0;
+    return { repoLinked, treeScanned };
+}
+function semanticCoverageFromPayload(payload) {
+    if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) {
+        return undefined;
+    }
+    const coverage = payload.semanticCoverage;
+    const parsed = code_reality_artifacts_schema_1.CodeRealitySemanticCoverageSchema.safeParse(coverage);
+    return parsed.success ? parsed.data : undefined;
+}
+async function loadSemanticMapped(supabase, projectId) {
+    const { data, error } = await ingestTable(supabase, 'workflow_artifacts')
+        .select('payload')
+        .eq('project_id', projectId)
+        .eq('artifact_type', workflow_artifacts_schema_1.WORKFLOW_ARTIFACT_TYPE.codeRealityGraphSnapshot)
+        .eq('status', 'accepted')
+        .order('created_at', { ascending: false })
+        .limit(1);
+    if (error !== null || data === null) {
+        return false;
+    }
+    const row = Array.isArray(data) ? data[0] : data;
+    if (row === undefined || row === null) {
+        return false;
+    }
+    return (0, is_code_reality_semantically_mapped_1.isCodeRealitySemanticallyMapped)(semanticCoverageFromPayload(row.payload));
+}
+async function hasAcceptedArtifactType(supabase, projectId, artifactType) {
+    // Use limit(1), not maybeSingle — repeated scans create multiple accepted rows;
+    // PostgREST maybeSingle errors when >1 row and gate falsely reports missing.
+    const { data, error } = await ingestTable(supabase, 'workflow_artifacts')
+        .select('id')
+        .eq('project_id', projectId)
+        .eq('artifact_type', artifactType)
+        .eq('status', 'accepted')
+        .order('created_at', { ascending: false })
+        .limit(1);
+    if (error !== null) {
+        return false;
+    }
+    if (Array.isArray(data)) {
+        return data.length > 0;
+    }
+    return data !== null;
+}
+async function loadAcceptedArtifacts(supabase, projectId) {
+    const [repoIntelSnapshot, repoPolicySnapshot] = await Promise.all([
+        hasAcceptedArtifactType(supabase, projectId, workflow_artifacts_schema_1.WORKFLOW_ARTIFACT_TYPE.repoIntelSnapshot),
+        hasAcceptedArtifactType(supabase, projectId, workflow_artifacts_schema_1.WORKFLOW_ARTIFACT_TYPE.repoPolicySnapshot),
+    ]);
+    return { repoIntelSnapshot, repoPolicySnapshot };
+}
+async function evaluateIngestGate(supabase, projectId, mode) {
+    const resolvedMode = await resolveWorkflowExecutionMode(supabase, projectId, mode);
+    const [{ repoLinked, treeScanned }, artifacts, semanticMapped] = await Promise.all([
+        loadRepoLinked(supabase, projectId),
+        loadAcceptedArtifacts(supabase, projectId),
+        loadSemanticMapped(supabase, projectId),
+    ]);
+    const scanComplete = treeScanned && semanticMapped;
+    const checks = {
+        repoLinked,
+        scanComplete,
+        repoIntelSnapshot: artifacts.repoIntelSnapshot,
+        repoPolicySnapshot: artifacts.repoPolicySnapshot,
+    };
+    const blockers = [];
+    if (resolvedMode === 'build-new' || resolvedMode === null) {
+        const status = repoLinked && !scanComplete ? 'passed_with_warnings' : 'passed';
+        if (repoLinked && !scanComplete) {
+            blockers.push('Repository linked but scan not complete — optional for build-new mode');
+        }
+        return ingest_gate_schema_1.IngestGateStatusSchema.parse({
+            status,
+            blockers,
+            checks,
+            mode: resolvedMode,
+        });
+    }
+    if (!repoLinked) {
+        blockers.push('Audit mode requires a linked GitHub repository before Specify/Plan');
+    }
+    if (!artifacts.repoIntelSnapshot) {
+        blockers.push('Audit mode requires an accepted repoIntelSnapshot artifact — run repo scan on the Ingest step');
+    }
+    if (!artifacts.repoPolicySnapshot) {
+        blockers.push('Audit mode requires an accepted repoPolicySnapshot artifact — complete repo scan to persist policy snapshot');
+    }
+    if (!scanComplete) {
+        if (treeScanned && !semanticMapped) {
+            blockers.push('Repository tree was scanned but the code graph is not a full semantic index (legacy 80-file cap or incomplete AST). Re-run ingest scan.');
+        }
+        else {
+            blockers.push('Repository scan has not completed — trigger scan from Ingest');
+        }
+    }
+    if (blockers.length > 0) {
+        return ingest_gate_schema_1.IngestGateStatusSchema.parse({
+            status: 'blocked',
+            blockers,
+            checks,
+            mode: resolvedMode,
+        });
+    }
+    return ingest_gate_schema_1.IngestGateStatusSchema.parse({
+        status: 'passed',
+        blockers: [],
+        checks,
+        mode: resolvedMode,
+    });
+}

package/dist/workflow/evaluate-repair-specify-gate.d.ts

@@ -0,0 +1,10 @@
+import type { WorkflowExecutionMode } from '../schemas/ai/workflow-execution-mode.schema';
+import { type RepairSpecifyGateStatus } from '../schemas/workflow/repair-specify-gate.schema';
+export type { RepairSpecifyGateStatus } from '../schemas/workflow/repair-specify-gate.schema';
+export { RepairSpecifyGateStatusSchema } from '../schemas/workflow/repair-specify-gate.schema';
+export type RepairSpecifyGateSupabaseClient = {
+    from: (relation: string) => object;
+};
+type RepairGateMode = WorkflowExecutionMode | null;
+export declare function repairSpecifyGateAllowsProgress(status: RepairSpecifyGateStatus): boolean;
+export declare function evaluateRepairSpecifyGate(supabase: RepairSpecifyGateSupabaseClient, projectId: string, mode: RepairGateMode): Promise<RepairSpecifyGateStatus>;

package/dist/workflow/evaluate-repair-specify-gate.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepairSpecifyGateStatusSchema = void 0;
+exports.repairSpecifyGateAllowsProgress = repairSpecifyGateAllowsProgress;
+exports.evaluateRepairSpecifyGate = evaluateRepairSpecifyGate;
+const normalize_workflow_execution_mode_1 = require("./normalize-workflow-execution-mode");
+const workflow_artifacts_schema_1 = require("../schemas/ai/workflow-artifacts.schema");
+const repair_specify_gate_schema_1 = require("../schemas/workflow/repair-specify-gate.schema");
+var repair_specify_gate_schema_2 = require("../schemas/workflow/repair-specify-gate.schema");
+Object.defineProperty(exports, "RepairSpecifyGateStatusSchema", { enumerable: true, get: function () { return repair_specify_gate_schema_2.RepairSpecifyGateStatusSchema; } });
+function repairTable(client, table) {
+    return client.from(table);
+}
+function isPassedStatus(status) {
+    return status === 'passed';
+}
+function repairSpecifyGateAllowsProgress(status) {
+    return isPassedStatus(status.status);
+}
+async function resolveWorkflowExecutionMode(supabase, projectId, mode) {
+    if (mode !== null) {
+        return mode;
+    }
+    const { data, error } = await repairTable(supabase, 'project_settings')
+        .select('settings')
+        .eq('project_id', projectId)
+        .maybeSingle();
+    if (error !== null || data === null || Array.isArray(data)) {
+        return null;
+    }
+    const settings = data.settings;
+    if (settings === null || settings === undefined) {
+        return null;
+    }
+    return (0, normalize_workflow_execution_mode_1.normalizeWorkflowExecutionMode)(settings.workflowExecutionMode);
+}
+async function loadAcceptedAuditArtifacts(supabase, projectId) {
+    const { data, error } = await repairTable(supabase, 'workflow_artifacts')
+        .select('artifact_type')
+        .eq('project_id', projectId)
+        .in('artifact_type', [
+        workflow_artifacts_schema_1.WORKFLOW_ARTIFACT_TYPE.findingsRegister,
+        workflow_artifacts_schema_1.WORKFLOW_ARTIFACT_TYPE.existingCapabilityClassification,
+    ])
+        .eq('status', 'accepted')
+        .limit(2);
+    if (error !== null) {
+        return { findingsRegister: false, existingCapabilityClassification: false };
+    }
+    const artifactRows = Array.isArray(data) ? data : data !== null ? [data] : [];
+    const types = new Set(artifactRows.map((row) => String(row.artifact_type)));
+    return {
+        findingsRegister: types.has(workflow_artifacts_schema_1.WORKFLOW_ARTIFACT_TYPE.findingsRegister),
+        existingCapabilityClassification: types.has(workflow_artifacts_schema_1.WORKFLOW_ARTIFACT_TYPE.existingCapabilityClassification),
+    };
+}
+async function evaluateRepairSpecifyGate(supabase, projectId, mode) {
+    const resolvedMode = await resolveWorkflowExecutionMode(supabase, projectId, mode);
+    const artifacts = await loadAcceptedAuditArtifacts(supabase, projectId);
+    const checks = {
+        findingsRegister: artifacts.findingsRegister,
+        existingCapabilityClassification: artifacts.existingCapabilityClassification,
+    };
+    if (!(0, normalize_workflow_execution_mode_1.isAuditLikeExecutionMode)(resolvedMode)) {
+        return repair_specify_gate_schema_1.RepairSpecifyGateStatusSchema.parse({
+            status: 'passed',
+            blockers: [],
+            checks,
+            mode: resolvedMode,
+        });
+    }
+    const blockers = [];
+    if (!artifacts.findingsRegister) {
+        blockers.push('Audit-existing Repair-Specify requires an accepted findingsRegister artifact — complete audit findings generation on the Ingest step');
+    }
+    if (!artifacts.existingCapabilityClassification) {
+        blockers.push('Audit-existing Repair-Specify requires an accepted existingCapabilityClassification artifact — complete capability classification after findings');
+    }
+    if (blockers.length > 0) {
+        return repair_specify_gate_schema_1.RepairSpecifyGateStatusSchema.parse({
+            status: 'blocked',
+            blockers,
+            checks,
+            mode: resolvedMode,
+        });
+    }
+    return repair_specify_gate_schema_1.RepairSpecifyGateStatusSchema.parse({
+        status: 'passed',
+        blockers: [],
+        checks,
+        mode: resolvedMode,
+    });
+}

package/dist/workflow/existing-codebase-step-area-map.d.ts

@@ -0,0 +1,4 @@
+import type { ExistingCodebaseStepArea } from '../schemas/workflow/existing-codebase-context.schema';
+/** Canonical workflow step key → existing-codebase area (design | governance | build | ship). */
+export declare const EXISTING_CODEBASE_STEP_AREA: Record<string, ExistingCodebaseStepArea>;
+export declare function resolveExistingCodebaseArea(step: string): ExistingCodebaseStepArea | null;

package/dist/workflow/existing-codebase-step-area-map.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXISTING_CODEBASE_STEP_AREA = void 0;
+exports.resolveExistingCodebaseArea = resolveExistingCodebaseArea;
+/** Canonical workflow step key → existing-codebase area (design | governance | build | ship). */
+exports.EXISTING_CODEBASE_STEP_AREA = {
+    ingest: 'design',
+    specify: 'design',
+    plan: 'design',
+    schema: 'design',
+    api: 'design',
+    ui: 'design',
+    constitution: 'governance',
+    tasks: 'build',
+    implement: 'build',
+    ci: 'ship',
+    deployments: 'ship',
+    review: 'ship',
+};
+function resolveExistingCodebaseArea(step) {
+    return exports.EXISTING_CODEBASE_STEP_AREA[step] ?? null;
+}