gswd 1.0.0 → 1.1.0

package/dist/lib/specify-journeys.js

@@ -0,0 +1,279 @@
+"use strict";
+/**
+ * GSWD Specify Journeys Module — Journey generation, FR extraction, cross-linking
+ *
+ * Produces journey structures and extracts functional requirements from journey steps.
+ * Bidirectional cross-linking: journeys reference FR IDs, FRs reference source journeys.
+ *
+ * Schema: GSWD_SPEC.md Section 6.1 (ID formats), 6.2 (scope tagging), 8.3 (specify workflow)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JOURNEY_TYPES = void 0;
+exports.assignScope = assignScope;
+exports.assignPriority = assignPriority;
+exports.generateJourneyStructure = generateJourneyStructure;
+exports.validateJourney = validateJourney;
+exports.extractFRsFromJourneys = extractFRsFromJourneys;
+exports.buildTraceabilityMap = buildTraceabilityMap;
+exports.validateFRCoverage = validateFRCoverage;
+const parse_js_1 = require("./parse.js");
+// ─── Constants ───────────────────────────────────────────────────────────────
+/**
+ * All 6 required journey types from GSWD_SPEC Section 8.3.
+ */
+exports.JOURNEY_TYPES = [
+    { type: 'onboarding', displayName: 'Onboarding' },
+    { type: 'core_action', displayName: 'Core Action' },
+    { type: 'view_results', displayName: 'View Results/History' },
+    { type: 'settings', displayName: 'Settings/Preferences' },
+    { type: 'error_states', displayName: 'Error States' },
+    { type: 'empty_states', displayName: 'Empty States' },
+];
+/** Journey types that allow fewer steps (minimum 3 instead of 5) */
+const REDUCED_STEP_TYPES = ['error_states', 'empty_states'];
+// ─── Scope & Priority Heuristics ────────────────────────────────────────────
+/**
+ * Assign scope based on journey type.
+ * Heuristic from CONTEXT.md locked decisions:
+ * - core_action/onboarding → v1
+ * - error_states/empty_states → v1 (required for polish)
+ * - view_results → v1
+ * - settings → v1 (default; caller can override to v2 for non-essential)
+ */
+function assignScope(journeyType) {
+    switch (journeyType) {
+        case 'onboarding':
+        case 'core_action':
+        case 'view_results':
+        case 'error_states':
+        case 'empty_states':
+        case 'settings':
+            return 'v1';
+        default:
+            return 'v1';
+    }
+}
+/**
+ * Assign priority based on journey type.
+ * Heuristic from CONTEXT.md locked decisions:
+ * - core_action/onboarding → P0 (blocks core journey)
+ * - error_states/empty_states/view_results/settings → P1 (required for complete v1)
+ */
+function assignPriority(journeyType) {
+    switch (journeyType) {
+        case 'core_action':
+        case 'onboarding':
+            return 'P0';
+        case 'error_states':
+        case 'empty_states':
+        case 'view_results':
+        case 'settings':
+            return 'P1';
+        default:
+            return 'P1';
+    }
+}
+// ─── Journey Structure Generation ───────────────────────────────────────────
+/**
+ * Format a journey ID: J-001, J-002, etc.
+ */
+function formatJourneyId(journeyNumber) {
+    return (0, parse_js_1.normalizeId)(`J-${journeyNumber}`);
+}
+/**
+ * Create a journey skeleton with proper ID and empty arrays.
+ */
+function generateJourneyStructure(type, journeyNumber) {
+    const typeInfo = exports.JOURNEY_TYPES.find((t) => t.type === type);
+    const displayName = typeInfo ? typeInfo.displayName : type;
+    return {
+        id: formatJourneyId(journeyNumber),
+        name: displayName,
+        type,
+        preconditions: [],
+        steps: [],
+        success: '',
+        failureModes: [],
+        acceptanceTests: [],
+        linkedFRs: [],
+        linkedNFRs: [],
+    };
+}
+// ─── Journey Validation ─────────────────────────────────────────────────────
+/**
+ * Validate a journey meets all structural requirements.
+ */
+function validateJourney(journey) {
+    const errors = [];
+    // ID format check
+    if (!/^J-\d{3,}$/.test(journey.id)) {
+        errors.push(`Invalid journey ID format: ${journey.id} (expected J-XXX)`);
+    }
+    // Minimum step count: 3 for error/empty, 5 for main journeys
+    const minSteps = REDUCED_STEP_TYPES.includes(journey.type) ? 3 : 5;
+    if (journey.steps.length < minSteps) {
+        errors.push(`Journey ${journey.id} has ${journey.steps.length} steps, minimum is ${minSteps} for type '${journey.type}'`);
+    }
+    // Maximum step count: 8 recommended
+    if (journey.steps.length > 8) {
+        errors.push(`Journey ${journey.id} has ${journey.steps.length} steps, recommended maximum is 8`);
+    }
+    // Failure modes >= 2
+    if (journey.failureModes.length < 2) {
+        errors.push(`Journey ${journey.id} has ${journey.failureModes.length} failure modes, minimum is 2`);
+    }
+    // Acceptance tests >= 1
+    if (journey.acceptanceTests.length < 1) {
+        errors.push(`Journey ${journey.id} has ${journey.acceptanceTests.length} acceptance tests, minimum is 1`);
+    }
+    // Failure mode conciseness (max 200 chars per scenario)
+    for (const fm of journey.failureModes) {
+        if (fm.scenario.length > 200) {
+            errors.push(`Journey ${journey.id} failure mode too long (${fm.scenario.length} chars, max 200): "${fm.scenario.substring(0, 50)}..."`);
+        }
+    }
+    // Acceptance test conciseness (max 200 chars, single statement)
+    for (const at of journey.acceptanceTests) {
+        if (at.length > 200) {
+            errors.push(`Journey ${journey.id} acceptance test too long (${at.length} chars, max 200): "${at.substring(0, 50)}..."`);
+        }
+    }
+    // Preconditions non-empty
+    if (journey.preconditions.length === 0) {
+        errors.push(`Journey ${journey.id} has empty preconditions`);
+    }
+    // Success non-empty
+    if (!journey.success || journey.success.trim() === '') {
+        errors.push(`Journey ${journey.id} has empty success outcome`);
+    }
+    return { valid: errors.length === 0, errors };
+}
+// ─── FR Extraction ──────────────────────────────────────────────────────────
+/**
+ * Format an FR ID: FR-001, FR-002, etc.
+ */
+function formatFRId(frNumber) {
+    return (0, parse_js_1.normalizeId)(`FR-${frNumber}`);
+}
+/**
+ * Extract FRs from journeys. Each journey step maps to at least 1 FR.
+ * Populates bidirectional cross-links:
+ * - Each step.frIds gets the generated FR IDs
+ * - Each journey.linkedFRs gets all FR IDs from its steps
+ * - Each FR.sourceJourneys references the parent journey
+ * - Each FR.sourceSteps references "J-XXX step N"
+ *
+ * Duplicate step descriptions merge into a single FR with multiple sources.
+ */
+function extractFRsFromJourneys(journeys) {
+    let frCounter = 1;
+    const frMap = new Map();
+    /** Map from normalized description to FR ID for deduplication */
+    const descriptionToFrId = new Map();
+    for (const journey of journeys) {
+        for (const step of journey.steps) {
+            const normalizedDesc = step.action.trim().toLowerCase();
+            if (descriptionToFrId.has(normalizedDesc)) {
+                // Merge: add this journey/step as additional source
+                const existingFrId = descriptionToFrId.get(normalizedDesc);
+                const existingFr = frMap.get(existingFrId);
+                if (!existingFr.sourceJourneys.includes(journey.id)) {
+                    existingFr.sourceJourneys.push(journey.id);
+                }
+                existingFr.sourceSteps.push(`${journey.id} step ${step.number}`);
+                step.frIds.push(existingFrId);
+            }
+            else {
+                // New FR
+                const frId = formatFRId(frCounter);
+                frCounter++;
+                const fr = {
+                    id: frId,
+                    description: step.action,
+                    scope: assignScope(journey.type),
+                    priority: assignPriority(journey.type),
+                    sourceJourneys: [journey.id],
+                    sourceSteps: [`${journey.id} step ${step.number}`],
+                };
+                frMap.set(frId, fr);
+                descriptionToFrId.set(normalizedDesc, frId);
+                step.frIds.push(frId);
+            }
+        }
+        // Populate journey.linkedFRs from step frIds
+        const journeyFrIds = new Set();
+        for (const step of journey.steps) {
+            for (const frId of step.frIds) {
+                journeyFrIds.add(frId);
+            }
+        }
+        journey.linkedFRs = Array.from(journeyFrIds).sort();
+    }
+    // Return sorted by FR ID
+    return Array.from(frMap.values()).sort((a, b) => {
+        const aNum = parseInt(a.id.split('-')[1], 10);
+        const bNum = parseInt(b.id.split('-')[1], 10);
+        return aNum - bNum;
+    });
+}
+// ─── Traceability ───────────────────────────────────────────────────────────
+/**
+ * Build traceability map for SPEC.md traceability table.
+ * Each entry maps an FR to its source journeys.
+ */
+function buildTraceabilityMap(frs) {
+    return frs.map((fr) => ({
+        frId: fr.id,
+        description: fr.description,
+        journeyRefs: fr.sourceSteps.map((stepRef) => {
+            // Convert "J-001 step 3" to "J-001 (step 3)"
+            const match = stepRef.match(/^(J-\d+)\s+step\s+(\d+)$/);
+            if (match) {
+                return `${match[1]} (step ${match[2]})`;
+            }
+            return stepRef;
+        }),
+    }));
+}
+// ─── Coverage Validation ────────────────────────────────────────────────────
+/**
+ * Validate FR coverage: every journey step has FRs, every FR has sources.
+ */
+function validateFRCoverage(journeys, frs) {
+    const errors = [];
+    // Every journey step must have at least 1 FR
+    for (const journey of journeys) {
+        for (const step of journey.steps) {
+            if (step.frIds.length === 0) {
+                errors.push(`Journey ${journey.id} step ${step.number} has no FR coverage`);
+            }
+        }
+    }
+    // Every FR must have at least 1 source journey
+    for (const fr of frs) {
+        if (fr.sourceJourneys.length === 0) {
+            errors.push(`FR ${fr.id} has no source journey (orphan FR)`);
+        }
+    }
+    // All FR IDs use correct format
+    for (const fr of frs) {
+        if (!/^FR-\d{3,}$/.test(fr.id)) {
+            errors.push(`Invalid FR ID format: ${fr.id} (expected FR-XXX)`);
+        }
+    }
+    // All scope tags are valid
+    const validScopes = ['v1', 'v2', 'out'];
+    for (const fr of frs) {
+        if (!validScopes.includes(fr.scope)) {
+            errors.push(`FR ${fr.id} has invalid scope: ${fr.scope}`);
+        }
+    }
+    // All priority tags are valid
+    const validPriorities = ['P0', 'P1', 'P2'];
+    for (const fr of frs) {
+        if (!validPriorities.includes(fr.priority)) {
+            errors.push(`FR ${fr.id} has invalid priority: ${fr.priority}`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/lib/specify-nfr.d.ts

@@ -0,0 +1,45 @@
+/**
+ * GSWD Specify NFR Module — Rule-based non-functional requirement generation
+ *
+ * Generates NFRs across 4 required categories: security, privacy, performance, observability.
+ * Thresholds calibrated for v1 MVP — conservative and achievable.
+ *
+ * Schema: GSWD_SPEC.md Section 6.1 (ID formats), 8.3 (specify workflow step 4)
+ */
+import type { FunctionalRequirement } from './specify-journeys.js';
+export type NFRCategory = 'security' | 'privacy' | 'performance' | 'observability';
+export interface NonFunctionalRequirement {
+    /** NFR ID in NFR-001 format */
+    id: string;
+    /** Category: security, privacy, performance, or observability */
+    category: NFRCategory;
+    /** What this NFR requires */
+    description: string;
+    /** Measurable threshold or acceptance criteria */
+    threshold: string;
+    /** FR-XXX IDs this NFR applies to */
+    linkedFRs: string[];
+}
+/**
+ * The 4 required NFR categories from GSWD_SPEC Section 8.3.
+ */
+export declare const NFR_CATEGORIES: {
+    category: NFRCategory;
+    description: string;
+}[];
+/**
+ * Generate NFRs from FR list across all 4 required categories.
+ * Rule-based: each category produces a standard set of NFRs.
+ * Thresholds calibrated for v1 MVP.
+ *
+ * @param frs - Functional requirements to link NFRs to
+ * @param decisionsContext - Optional DECISIONS.md content for calibration
+ */
+export declare function generateNFRs(frs: FunctionalRequirement[], decisionsContext?: string): NonFunctionalRequirement[];
+/**
+ * Validate NFRs: all 4 categories represented, IDs correct, fields non-empty.
+ */
+export declare function validateNFRs(nfrs: NonFunctionalRequirement[]): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/lib/specify-nfr.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * GSWD Specify NFR Module — Rule-based non-functional requirement generation
+ *
+ * Generates NFRs across 4 required categories: security, privacy, performance, observability.
+ * Thresholds calibrated for v1 MVP — conservative and achievable.
+ *
+ * Schema: GSWD_SPEC.md Section 6.1 (ID formats), 8.3 (specify workflow step 4)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFR_CATEGORIES = void 0;
+exports.generateNFRs = generateNFRs;
+exports.validateNFRs = validateNFRs;
+const parse_js_1 = require("./parse.js");
+// ─── Constants ───────────────────────────────────────────────────────────────
+/**
+ * The 4 required NFR categories from GSWD_SPEC Section 8.3.
+ */
+exports.NFR_CATEGORIES = [
+    { category: 'security', description: 'Input validation, authentication, authorization' },
+    { category: 'privacy', description: 'Data handling, user consent, PII protection' },
+    { category: 'performance', description: 'Response time, throughput, resource usage' },
+    { category: 'observability', description: 'Logging, error tracking, health checks' },
+];
+// ─── NFR Generation ─────────────────────────────────────────────────────────
+/**
+ * Format an NFR ID: NFR-001, NFR-002, etc.
+ */
+function formatNFRId(nfrNumber) {
+    return (0, parse_js_1.normalizeId)(`NFR-${nfrNumber}`);
+}
+/**
+ * Generate NFRs from FR list across all 4 required categories.
+ * Rule-based: each category produces a standard set of NFRs.
+ * Thresholds calibrated for v1 MVP.
+ *
+ * @param frs - Functional requirements to link NFRs to
+ * @param decisionsContext - Optional DECISIONS.md content for calibration
+ */
+function generateNFRs(frs, decisionsContext) {
+    const nfrs = [];
+    let counter = 1;
+    const v1FrIds = frs.filter((fr) => fr.scope === 'v1').map((fr) => fr.id);
+    const p0FrIds = frs.filter((fr) => fr.priority === 'P0').map((fr) => fr.id);
+    // ─── Security NFRs ───────────────────────────────────────────────────────
+    nfrs.push({
+        id: formatNFRId(counter++),
+        category: 'security',
+        description: 'All user-facing input fields must be validated before processing',
+        threshold: 'No unvalidated user input reaches data store or business logic',
+        linkedFRs: v1FrIds.length > 0 ? v1FrIds : [],
+    });
+    nfrs.push({
+        id: formatNFRId(counter++),
+        category: 'security',
+        description: 'All authenticated operations must verify session validity',
+        threshold: 'Unauthorized access returns 401/403 within 100ms',
+        linkedFRs: p0FrIds.length > 0 ? p0FrIds : [],
+    });
+    nfrs.push({
+        id: formatNFRId(counter++),
+        category: 'security',
+        description: 'Operations must enforce role-based access when roles are defined',
+        threshold: 'Users can only access resources they own or are authorized to view',
+        linkedFRs: v1FrIds.length > 0 ? v1FrIds : [],
+    });
+    // ─── Privacy NFRs ────────────────────────────────────────────────────────
+    nfrs.push({
+        id: formatNFRId(counter++),
+        category: 'privacy',
+        description: 'User data must not be logged in plain text or exposed in error messages',
+        threshold: 'No PII appears in application logs or stack traces',
+        linkedFRs: v1FrIds.length > 0 ? v1FrIds : [],
+    });
+    nfrs.push({
+        id: formatNFRId(counter++),
+        category: 'privacy',
+        description: 'User data collection requires explicit consent where applicable',
+        threshold: 'No data stored without user-initiated action',
+        linkedFRs: v1FrIds.length > 0 ? v1FrIds : [],
+    });
+    // ─── Performance NFRs ────────────────────────────────────────────────────
+    nfrs.push({
+        id: formatNFRId(counter++),
+        category: 'performance',
+        description: 'Core user actions must complete within acceptable time',
+        threshold: 'P95 response time < 2s for core actions, < 5s for complex operations',
+        linkedFRs: p0FrIds.length > 0 ? p0FrIds : [],
+    });
+    nfrs.push({
+        id: formatNFRId(counter++),
+        category: 'performance',
+        description: 'System must handle expected v1 concurrent load',
+        threshold: 'Supports 100 concurrent users without degradation',
+        linkedFRs: v1FrIds.length > 0 ? v1FrIds : [],
+    });
+    // ─── Observability NFRs ──────────────────────────────────────────────────
+    nfrs.push({
+        id: formatNFRId(counter++),
+        category: 'observability',
+        description: 'All errors must be captured with context for debugging',
+        threshold: 'Errors include timestamp, user context (anonymized), stack trace, and request ID',
+        linkedFRs: v1FrIds.length > 0 ? v1FrIds : [],
+    });
+    nfrs.push({
+        id: formatNFRId(counter++),
+        category: 'observability',
+        description: 'System health must be verifiable',
+        threshold: 'Health endpoint returns status within 1s',
+        linkedFRs: [],
+    });
+    nfrs.push({
+        id: formatNFRId(counter++),
+        category: 'observability',
+        description: 'Key operations must produce structured logs',
+        threshold: 'All state-changing operations produce at least one log entry',
+        linkedFRs: v1FrIds.length > 0 ? v1FrIds : [],
+    });
+    return nfrs;
+}
+// ─── NFR Validation ─────────────────────────────────────────────────────────
+/**
+ * Validate NFRs: all 4 categories represented, IDs correct, fields non-empty.
+ */
+function validateNFRs(nfrs) {
+    const errors = [];
+    const categoriesPresent = new Set();
+    for (const nfr of nfrs) {
+        categoriesPresent.add(nfr.category);
+        // ID format check
+        if (!/^NFR-\d{3,}$/.test(nfr.id)) {
+            errors.push(`Invalid NFR ID format: ${nfr.id} (expected NFR-XXX)`);
+        }
+        // Non-empty description
+        if (!nfr.description || nfr.description.trim() === '') {
+            errors.push(`NFR ${nfr.id} has empty description`);
+        }
+        // Non-empty threshold
+        if (!nfr.threshold || nfr.threshold.trim() === '') {
+            errors.push(`NFR ${nfr.id} has empty threshold`);
+        }
+    }
+    // All 4 categories represented
+    const requiredCategories = ['security', 'privacy', 'performance', 'observability'];
+    for (const category of requiredCategories) {
+        if (!categoriesPresent.has(category)) {
+            errors.push(`Missing required NFR category: ${category}`);
+        }
+    }
+    // Sequential IDs (warning-level, but include in errors for strict validation)
+    for (let i = 0; i < nfrs.length; i++) {
+        const expectedId = formatNFRId(i + 1);
+        if (nfrs[i].id !== expectedId) {
+            errors.push(`Non-sequential NFR ID: expected ${expectedId}, got ${nfrs[i].id}`);
+            break; // Only report first gap
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/lib/specify-roles.d.ts

@@ -0,0 +1,46 @@
+/**
+ * GSWD Specify Roles Module — Roles & permissions checkpoint
+ *
+ * Collects roles and permissions from the founder before journey mapping.
+ * In --auto mode, returns sensible defaults (single admin for v1 MVP).
+ *
+ * Schema: GSWD_SPEC.md Section 8.3 step 1
+ */
+export interface Role {
+    /** Role name (e.g., 'admin', 'viewer') */
+    name: string;
+    /** What this role can do */
+    description: string;
+    /** High-level permission descriptions */
+    permissions: string[];
+}
+export interface RolesConfig {
+    /** Defined roles */
+    roles: Role[];
+    /** Permission model type */
+    permissionModel: 'simple' | 'rbac' | 'abac';
+    /** Additional notes about the roles setup */
+    notes: string;
+}
+/**
+ * Sensible v1 MVP default: single admin role with full permissions.
+ */
+export declare function defaultRolesConfig(): RolesConfig;
+export interface CollectRolesOptions {
+    /** If true, skip checkpoint and return defaults */
+    auto: boolean;
+}
+/**
+ * Collect roles & permissions configuration.
+ *
+ * In auto mode: returns default config immediately (no interaction).
+ * In interactive mode: would render checkpoint box for user input.
+ * (Interactive mode deferred to Phase 6 — auto is the primary path for now.)
+ */
+export declare function collectRoles(options: CollectRolesOptions): Promise<RolesConfig>;
+/**
+ * Format RolesConfig for insertion into SPEC.md "## Roles & Permissions" section.
+ *
+ * Produces a markdown table of roles with permissions.
+ */
+export declare function formatRolesForSpec(config: RolesConfig): string;

package/dist/lib/specify-roles.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * GSWD Specify Roles Module — Roles & permissions checkpoint
+ *
+ * Collects roles and permissions from the founder before journey mapping.
+ * In --auto mode, returns sensible defaults (single admin for v1 MVP).
+ *
+ * Schema: GSWD_SPEC.md Section 8.3 step 1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRolesConfig = defaultRolesConfig;
+exports.collectRoles = collectRoles;
+exports.formatRolesForSpec = formatRolesForSpec;
+// ─── Default Configuration ───────────────────────────────────────────────────
+/**
+ * Sensible v1 MVP default: single admin role with full permissions.
+ */
+function defaultRolesConfig() {
+    return {
+        roles: [
+            {
+                name: 'admin',
+                description: 'Full access to all features and settings',
+                permissions: ['create', 'read', 'update', 'delete', 'manage_settings'],
+            },
+        ],
+        permissionModel: 'simple',
+        notes: 'Single admin role for v1 MVP — expand when multi-user is needed',
+    };
+}
+/**
+ * Collect roles & permissions configuration.
+ *
+ * In auto mode: returns default config immediately (no interaction).
+ * In interactive mode: would render checkpoint box for user input.
+ * (Interactive mode deferred to Phase 6 — auto is the primary path for now.)
+ */
+async function collectRoles(options) {
+    if (options.auto) {
+        return defaultRolesConfig();
+    }
+    // Interactive mode: return default with note about deferral
+    // Full interactive collection deferred to Phase 6 (Bootstrap + Auto)
+    return {
+        ...defaultRolesConfig(),
+        notes: 'Deferred — using admin-only for now',
+    };
+}
+// ─── Formatting ──────────────────────────────────────────────────────────────
+/**
+ * Format RolesConfig for insertion into SPEC.md "## Roles & Permissions" section.
+ *
+ * Produces a markdown table of roles with permissions.
+ */
+function formatRolesForSpec(config) {
+    const lines = [];
+    // Permission model description
+    lines.push(`**Permission Model:** ${formatPermissionModel(config.permissionModel)}`);
+    lines.push('');
+    // Roles table
+    lines.push('| Role | Description | Permissions |');
+    lines.push('|------|-------------|-------------|');
+    for (const role of config.roles) {
+        const perms = role.permissions.join(', ');
+        lines.push(`| ${role.name} | ${role.description} | ${perms} |`);
+    }
+    // Notes
+    if (config.notes) {
+        lines.push('');
+        lines.push(`> ${config.notes}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Format permission model name for display.
+ */
+function formatPermissionModel(model) {
+    switch (model) {
+        case 'simple':
+            return 'Simple (single role or flat permissions)';
+        case 'rbac':
+            return 'RBAC (Role-Based Access Control)';
+        case 'abac':
+            return 'ABAC (Attribute-Based Access Control)';
+        default:
+            return model;
+    }
+}

package/dist/lib/specify.d.ts

@@ -0,0 +1,70 @@
+/**
+ * GSWD Specify Workflow Orchestrator
+ *
+ * Full pipeline: roles checkpoint -> journey mapping -> FR extraction ->
+ * NFR generation -> architecture + integrations -> write artifacts -> state
+ * Implements GSWD_SPEC Section 8.3 end-to-end.
+ *
+ * Both interactive and auto modes are supported:
+ * - Interactive: presents checkpoints for roles, journey review, FR confirmation
+ * - Auto: uses defaults, skips reviews, auto-defers paid integrations
+ *
+ * Schema: GSWD_SPEC.md Section 8.3
+ */
+import type { Journey } from './specify-journeys.js';
+import type { SpawnFn } from './specify-agents.js';
+export interface SpecifyOptions {
+    /** Use auto policy for all checkpoints */
+    auto: boolean;
+    /** Resume from last checkpoint */
+    resume?: boolean;
+    /** Integration budget override */
+    integrationBudget?: number;
+    /** Override .planning/ path (for testing) */
+    planningDir?: string;
+    /** Override config.json path (for testing) */
+    configPath?: string;
+    /** Override templates directory path (for testing) */
+    templatesDir?: string;
+    /** Task() wrapper for agent spawning (injectable for testing) */
+    spawnFn?: SpawnFn;
+    /** Skip agent spawning, use provided journeys directly (for testing) */
+    skipAgents?: boolean;
+    /** Pre-built journeys (for testing or resume) */
+    providedJourneys?: Journey[];
+    /** Pre-built architecture content (for testing) */
+    providedArchitecture?: string;
+    /** Pre-built integrations content (for testing) */
+    providedIntegrations?: string;
+}
+export interface SpecifyResult {
+    /** Overall status */
+    status: 'complete' | 'failed' | 'interrupted';
+    /** File paths of written artifacts */
+    artifacts: string[];
+    /** Count of journeys generated */
+    journeyCount: number;
+    /** Count of FRs extracted */
+    frCount: number;
+    /** Count of NFRs generated */
+    nfrCount: number;
+    /** Count of integrations */
+    integrationCount: number;
+    /** Count of architecture components */
+    componentCount: number;
+    /** Error messages if any */
+    errors?: string[];
+}
+/**
+ * Run the Specify workflow end-to-end.
+ *
+ * Implements GSWD_SPEC Section 8.3:
+ * 1. Roles & Permissions checkpoint
+ * 2. Journey mapping
+ * 3. FR extraction
+ * 4. NFR generation
+ * 5. Architecture + Integrations (parallel agents)
+ * 6. Write 5 artifacts
+ * 7. Update state
+ */
+export declare function runSpecify(options: SpecifyOptions): Promise<SpecifyResult>;