@wrongstack/requirement-intake 0.299.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ECOSTACK TECHNOLOGY OÜ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,237 @@
+# @wrongstack/requirement-intake
+
+Requirements Intake — collect, preserve, validate, normalize, and submit
+unstructured software development requests as structured intake records.
+
+This module is **upstream of spec-driven development**. It only collects and
+preserves the initial request and its supporting information. It does not
+plan tasks, generate executable specifications, resolve contradictions,
+produce architecture, or generate code — those concerns belong to separate
+modules (`@wrongstack/sdd` and friends).
+
+## Design goals
+
+1. **The original request is sacred.** The exact user input is stored verbatim
+   in `originalRequest` and is immutable after creation. No update path, no
+   LLM suggestion, and no normalization step can overwrite it.
+2. **Every derived value is separable and source-annotated.** Normalized,
+   summarized, categorized, or LLM-generated content is stored separately and
+   tagged with `fieldSources` / `source` (`user`, `llm`, `deterministic`).
+3. **LLM output is always a proposal.** It is validated against a schema,
+   stored with `source: 'llm'`, and only applied after an explicit user
+   `acceptSuggestion`. It never controls persistence, authorization, or
+   lifecycle state.
+4. **Deterministic validation and lifecycle.** Enums are authoritative;
+   unknown request types map to `other`/`unspecified`; status transitions are
+   enforced by application logic.
+5. **Safety first.** Authorization is enforced on every operation (fail
+   closed), concurrent writes use optimistic concurrency + file locks,
+   create/submit are idempotent, and no sensitive request content ever
+   reaches logs, metrics, or events.
+
+## Quick start
+
+```ts
+import {
+  RequirementIntakeStore,
+  RequirementIntakeService,
+  AllowAllIntakeAuthorizer,
+} from '@wrongstack/requirement-intake';
+
+const store = new RequirementIntakeStore({ baseDir: '.wrongstack/requirement-intakes' });
+const service = new RequirementIntakeService({
+  store,
+  authorizer: new AllowAllIntakeAuthorizer(), // wire your own policy in production
+});
+
+const ctx = { id: 'user-42', type: 'user', projectId: 'proj_01ABCDEF123456789' };
+
+const { record } = await service.createIntake(
+  {
+    projectId: ctx.projectId,
+    originalRequest: 'Add email-based password reset so users can recover access.',
+    requestedBy: ctx.id,
+  },
+  ctx,
+);
+
+await service.addAnswer(record.id, { field: 'business_goal', answer: 'Reduce support tickets' }, ctx);
+const { record: submitted } = await service.submitIntake(record.id, ctx);
+```
+
+## Operations
+
+| Operation | Method |
+|---|---|
+| Create intake | `createIntake(input, ctx)` |
+| Update draft | `updateIntake(id, patch, ctx, expectedVersion?)` |
+| Get intake | `getIntake(id, ctx)` |
+| Add answer | `addAnswer(id, { field, answer }, ctx)` |
+| Update answer | `updateAnswer(id, answerId, { answer }, ctx)` |
+| Attach resources | `attachResource(id, { attachment \| relatedResource }, ctx)` |
+| LLM suggestions | `generateSuggestions(id, ctx, focus?)` |
+| Accept suggestion | `acceptSuggestion(id, proposalId, ctx)` |
+| Reject suggestion | `rejectSuggestion(id, proposalId, ctx)` |
+| Submit | `submitIntake(id, ctx)` |
+| Cancel | `cancelIntake(id, ctx, reason?)` |
+| Archive | `archiveIntake(id, ctx)` |
+| List project intakes | `listIntakes(projectId, ctx, filter?)` |
+| Pending questions | `pendingQuestions(id, ctx)` |
+
+Every mutation accepts an optional `expectedVersion` for optimistic
+concurrency; a mismatch throws `IntakeConflictError`.
+
+## Data model
+
+The record adapts the spec's snake_case JSON to the codebase's camelCase
+convention:
+
+| Concept (spec) | Field |
+|---|---|
+| `id` | `id` — `reqi_<ulid>` |
+| `project_id` | `projectId` |
+| `original_request` | `originalRequest` — immutable |
+| `normalized_summary` | `normalizedSummary` |
+| `request_type` | `requestType` |
+| `requested_by` | `requestedBy` |
+| `business_goal` | `businessGoal` |
+| `target_users` | `targetUsers` |
+| `expected_outcome` | `expectedOutcome` |
+| `scope_notes` | `scopeNotes` |
+| `provided_context` | `providedContext` |
+| `related_resources` | `relatedResources` |
+| `created_at` / `updated_at` | `createdAt` / `updatedAt` (epoch ms) |
+
+Plus: `status`, `priority`, `constraints`, `attachments`, `answers`,
+`questions`, `llmSuggestions`, `metadata`, `fieldSources`, `version`,
+`history`, submission/cancellation/archival stamps, and the create
+`idempotencyKey`.
+
+Request types: `feature`, `bug_fix`, `refactor`, `performance`, `security`,
+`ui_change`, `api_change`, `infrastructure`, `migration`, `testing`,
+`documentation`, `maintenance`, `other`, `unspecified`.
+
+Lifecycle: `draft → collecting_information → submitted`, `draft → cancelled`,
+`collecting_information → cancelled`, `submitted/cancelled → archived`.
+Invalid transitions throw `IntakeStateTransitionError`. Duplicate submission
+is idempotent (returns the submitted record).
+
+## LLM suggestions
+
+Wire an adapter that implements `LlmSuggestionGenerator` and returns
+structured output:
+
+```ts
+const service = new RequirementIntakeService({
+  store,
+  authorizer,
+  generator: {
+    async generate({ record, focus }) {
+      // call your LLM; return structured JSON only
+      return {
+        suggested_title: 'Add email-based password reset',
+        normalized_summary: 'Allow users to reset forgotten passwords through an email link.',
+        suggested_request_type: 'feature',
+        extracted_constraints: ['Rate-limit reset emails'],
+        suggested_questions: [{ field: 'target_users', question: 'Which users?' }],
+      };
+    },
+  },
+});
+```
+
+Output is validated with zod (`llmSuggestionOutputSchema`); malformed output
+throws `IntakeSuggestionError` and is never persisted. Generating suggestions
+moves a `draft` to `collecting_information` (application logic, not the LLM).
+
+## Authorization
+
+Pass an `IntakeAuthorizer` to the service. The module fails closed: without a
+permissive authorizer, every operation throws `IntakeAuthorizationError`.
+
+- `AllowAllIntakeAuthorizer` — embedded/single-user hosts.
+- `DenyAllIntakeAuthorizer` — fail-closed default.
+- `ProjectMembershipIntakeAuthorizer` — membership-based policy with optional
+  owner-only operations and built-in cross-project denial.
+
+The service always verifies `record.projectId === ctx.projectId` through the
+authorizer and rejects `listIntakes` for a project different from the
+context's project.
+
+## Persistence & concurrency
+
+File-backed JSON store (mirrors `SpecStore` conventions):
+
+```
+baseDir/<id>.json           — one record per file
+baseDir/_index.json         — listing index
+baseDir/_idempotency.json   — create-idempotency key map
+```
+
+- Every write goes through `atomicWrite` (temp + rename) under a per-file
+  exclusive lock (`withFileLock`), serializing concurrent writers within and
+  across processes.
+- `version` is a per-write mutation counter; passing a stale `expectedVersion`
+  throws `IntakeConflictError` instead of silently overwriting.
+- Create is idempotent via `idempotencyKey` (hashed in `_idempotency.json`).
+- Change history is appended per write (`history`, capped at 200 entries).
+- Records are never hard-deleted; `archived` is the soft-delete path.
+
+Default location: `~/.wrongstack/projects/<slug>/requirement-intakes`
+(`resolveWstackPaths(...).projectRequirementIntakes` — the `baseDir` option is
+optional and falls back to this when omitted).
+
+## Integrations
+
+- **REST** — the WebUI server exposes the intake API under
+  `/api/projects/:projectId/requirement-intakes` (create/list) and
+  `/api/requirement-intakes/:intakeId` (get/patch/answers/suggestions/
+  submit/cancel/archive), token-gated like every other `/api` route. The
+  service is constructed per project in `startHttpServer` with an
+  `AllowAllIntakeAuthorizer` (the HTTP token gate is the authorization
+  boundary); hosts may inject their own via `intakeService`.
+- **CLI** — `/intake [text]` creates and submits an intake record from the
+  given text or the most recent session prompt (see `docs/slash/intake.md`).
+- **MCP** — `@wrongstack/requirement-intake-mcp` provides
+  `wstack-requirement-intake-mcp`, a project-scoped MCP server with
+  `requirement_intake_list` (read tier) and `requirement_intake_submit`
+  (writable tier) tools, mirroring the kanban-mcp pattern.
+- **SDD** — `startInterviewFromIntake(driver, record)` /
+  `intakeToInterviewKickoff(record)` in `@wrongstack/sdd` seed a spec-builder
+  interview from a submitted intake record, using the original request as the
+  interview intent and the collected facts as project context.
+
+## Observability
+
+- **Events** — `RequirementIntakeCreated`, `RequirementIntakeUpdated`,
+  `RequirementIntakeInformationRequested`, `RequirementIntakeSubmitted`,
+  `RequirementIntakeCancelled`, `RequirementIntakeArchived`. Payloads carry
+  identifiers and safe metadata only — never request content.
+- **Metrics** (`IntakeMetrics`) — created/submitted/cancelled/archived counts,
+  duplicate create/submit, validation failures, suggestion
+  requested/succeeded/failed, unauthorized attempts, and
+  `intake.time_to_submit` duration.
+- **Logging** (`IntakeLogger`) — structured, scope-tagged, identifiers only.
+
+All three are injectable; defaults are silent. Request content, answers, and
+metadata values are never passed to the logger, metrics, or events.
+
+## Security
+
+- Prompt-injection text is ordinary data: preserved verbatim, never executed.
+- Oversized input, blank fields, malformed metadata, and unknown enums are
+  rejected/normalized deterministically.
+- Cross-project access is denied; automation identities receive only what the
+  authorizer grants.
+- Sensitive content does not leak into logs/events (covered by tests).
+
+## Development
+
+```bash
+pnpm --filter @wrongstack/requirement-intake typecheck
+pnpm --filter @wrongstack/requirement-intake test
+pnpm --filter @wrongstack/requirement-intake build
+```
+
+Tests: 147 unit/integration/security tests in `tests/` (run under both the
+package config and the workspace root config).

package/dist/authorization.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Requirements Intake — authorization.
+ *
+ * The module enforces authorization through an injected `IntakeAuthorizer`.
+ * Hosts wire their own policy (session user, project membership, agent
+ * permissions). The service awaits `isAllowed` on every operation and throws
+ * `IntakeAuthorizationError` on denial, so a misconfigured host fails closed
+ * unless it explicitly installs an allow-all policy.
+ */
+import type { IntakeContext, RequirementIntakeRecord } from './types.js';
+export declare const INTAKE_OPERATIONS: readonly ['create', 'read', 'list', 'update', 'answer', 'attach', 'suggest', 'accept_suggestion', 'reject_suggestion', 'submit', 'cancel', 'archive'];
+export type IntakeOperation = (typeof INTAKE_OPERATIONS)[number];
+export interface IntakeAuthorizer {
+    /**
+     * Decide whether `actor` may perform `operation` in `ctx.projectId`,
+     * optionally against the target record. May return a Promise for
+     * async resolvers. Implementations must deny cross-project access:
+     * the record's `projectId` must equal `ctx.projectId`.
+     */
+    isAllowed(operation: IntakeOperation, ctx: IntakeContext, record?: RequirementIntakeRecord | undefined): boolean | Promise<boolean>;
+}
+/** Permissive policy — every operation is allowed. For embedded/single-user hosts. */
+export declare class AllowAllIntakeAuthorizer implements IntakeAuthorizer {
+    isAllowed(_operation: IntakeOperation, _ctx: IntakeContext, _record?: RequirementIntakeRecord | undefined): boolean;
+}
+/** Fail-closed policy — every operation is denied. Default safety net. */
+export declare class DenyAllIntakeAuthorizer implements IntakeAuthorizer {
+    isAllowed(_operation: IntakeOperation, _ctx: IntakeContext, _record?: RequirementIntakeRecord | undefined): boolean;
+}
+export interface ProjectMembershipIntakeAuthorizerOptions {
+    /** Resolve which projects an actor belongs to. */
+    projectsOf: (actorId: string, actorType: string) => Promise<ReadonlySet<string>> | ReadonlySet<string>;
+    /** Operations that additionally require the actor to own the record. */
+    ownerOnlyOperations?: ReadonlySet<IntakeOperation> | undefined;
+}
+/**
+ * Membership-based policy: an actor may operate on a project only when the
+ * `projectsOf` resolver lists it. Cross-project access is always denied.
+ * `ownerOnlyOperations` (e.g. `submit`) can additionally require
+ * `record.requestedBy === actor.id`.
+ */
+export declare class ProjectMembershipIntakeAuthorizer implements IntakeAuthorizer {
+    private readonly projectsOf;
+    private readonly ownerOnly;
+    constructor(options: ProjectMembershipIntakeAuthorizerOptions);
+    isAllowed(operation: IntakeOperation, ctx: IntakeContext, record?: RequirementIntakeRecord | undefined): Promise<boolean>;
+}
+//# sourceMappingURL=authorization.d.ts.map

package/dist/constants.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Requirements Intake — domain constants.
+ *
+ * Deterministic enums and size limits. The authoritative request-type and
+ * status values live here; unknown values are normalized (see validation.ts)
+ * and never persisted as uncontrolled strings.
+ */
+export declare const INTAKE_ID_PREFIX = "reqi_";
+export declare const ANSWER_ID_PREFIX = "ans_";
+export declare const ATTACHMENT_ID_PREFIX = "attach_";
+export declare const RELATED_RESOURCE_ID_PREFIX = "relres_";
+export declare const QUESTION_ID_PREFIX = "q_";
+export declare const SUGGESTION_ID_PREFIX = "sug_";
+/**
+ * Supported request types. `unspecified` is the neutral default; `other`
+ * absorbs any unknown/unsupported value supplied by callers or the LLM.
+ */
+export declare const REQUEST_TYPES: readonly ['feature', 'bug_fix', 'refactor', 'performance', 'security', 'ui_change', 'api_change', 'infrastructure', 'migration', 'testing', 'documentation', 'maintenance', 'other', 'unspecified'];
+export type RequestType = (typeof REQUEST_TYPES)[number];
+/** Deterministic lifecycle. Only application logic may change status. */
+export declare const INTAKE_STATUSES: readonly ['draft', 'collecting_information', 'submitted', 'cancelled', 'archived'];
+export type IntakeStatus = (typeof INTAKE_STATUSES)[number];
+export declare const INTAKE_PRIORITIES: readonly ['unspecified', 'low', 'medium', 'high', 'critical'];
+export type IntakePriority = (typeof INTAKE_PRIORITIES)[number];
+/** Who produced a stored value. Distinguishes user vs machine content. */
+export declare const INTAKE_FIELD_SOURCES: readonly ['user', 'llm', 'deterministic', 'system'];
+export type IntakeFieldSource = (typeof INTAKE_FIELD_SOURCES)[number];
+/** Record fields that carry a source annotation. */
+export declare const INTAKE_FIELDS: readonly ['title', 'normalized_summary', 'request_type', 'priority', 'business_goal', 'target_users', 'expected_outcome', 'scope_notes', 'constraints', 'provided_context', 'attachments', 'related_resources'];
+export type IntakeField = (typeof INTAKE_FIELDS)[number];
+export declare const INTAKE_ATTACHMENT_KINDS: readonly ['file', 'image', 'document', 'link', 'other'];
+export type IntakeAttachmentKind = (typeof INTAKE_ATTACHMENT_KINDS)[number];
+export declare const RELATED_RESOURCE_KINDS: readonly ['spec', 'issue', 'pr', 'doc', 'url', 'other'];
+export type RelatedResourceKind = (typeof RELATED_RESOURCE_KINDS)[number];
+export declare const INTAKE_QUESTION_STATUSES: readonly ['unanswered', 'answered', 'skipped'];
+export type IntakeQuestionStatus = (typeof INTAKE_QUESTION_STATUSES)[number];
+export declare const SUGGESTION_STATUSES: readonly ['pending', 'accepted', 'rejected'];
+export type SuggestionStatus = (typeof SUGGESTION_STATUSES)[number];
+export declare const SUGGESTION_KINDS: readonly ['title', 'summary', 'request_type', 'priority', 'question', 'constraint', 'target_user', 'outcome'];
+export type SuggestionKind = (typeof SUGGESTION_KINDS)[number];
+/** Maximum length of the original request, in characters. */
+export declare const MAX_REQUEST_LENGTH = 100000;
+/** Maximum length of a title, in characters. */
+export declare const MAX_TITLE_LENGTH = 200;
+/** Maximum length of the normalized summary, in characters. */
+export declare const MAX_SUMMARY_LENGTH = 2000;
+/** Maximum length of any free-form string field (goal, outcome, scope notes, …). */
+export declare const MAX_STRING_FIELD_LENGTH = 5000;
+/** Maximum number of items in a list field (target users, constraints, …). */
+export declare const MAX_ARRAY_ITEMS = 50;
+/** Maximum number of attachments on one intake record. */
+export declare const MAX_ATTACHMENTS = 20;
+/** Maximum number of related resources on one intake record. */
+export declare const MAX_RELATED_RESOURCES = 50;
+/** Maximum number of top-level metadata keys. */
+export declare const MAX_METADATA_ENTRIES = 50;
+/** Maximum serialized metadata size, in bytes. */
+export declare const MAX_METADATA_BYTES: number;
+/** Maximum length of an intake answer, in characters. */
+export declare const MAX_ANSWER_LENGTH = 50000;
+/** Maximum length of an idempotency key, in characters. */
+export declare const MAX_IDEMPOTENCY_KEY_LENGTH = 128;
+/** Maximum length of an attachment/related-resource reference. */
+export declare const MAX_REFERENCE_LENGTH = 500;
+/** Maximum length of a question text. */
+export declare const MAX_QUESTION_LENGTH = 500;
+/** Maximum number of change-history entries retained per record. */
+export declare const MAX_HISTORY_ENTRIES = 200;
+/** Maximum number of pending LLM suggestions retained per record. */
+export declare const MAX_SUGGESTIONS = 100;
+/** Deterministic fallback summary length when no LLM summary is available. */
+export declare const DETERMINISTIC_SUMMARY_LENGTH = 240;
+/**
+ * Default intake question catalog. Hosts may override via create options.
+ * `field` values map to record properties through the answer pipeline
+ * (see service.ts) or stay as structured answers for later modules.
+ */
+export interface IntakeQuestionTemplate {
+    field: string;
+    question: string;
+    required: boolean;
+}
+export declare const DEFAULT_INTAKE_QUESTIONS: readonly IntakeQuestionTemplate[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/errors.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Requirements Intake — typed errors.
+ *
+ * Every failure path throws an `IntakeError` subclass carrying a stable
+ * `code` so hosts can map them to HTTP statuses, CLI messages, or events.
+ */
+export type IntakeErrorCode = 'INTAKE_VALIDATION_ERROR' | 'INTAKE_NOT_FOUND' | 'INTAKE_INVALID_TRANSITION' | 'INTAKE_STATUS_LOCKED' | 'INTAKE_CONFLICT' | 'INTAKE_UNAUTHORIZED' | 'INTAKE_SUGGESTION_ERROR';
+export declare class IntakeError extends Error {
+    readonly code: IntakeErrorCode;
+    constructor(code: IntakeErrorCode, message: string, options?: ErrorOptions);
+}
+/** One field-level validation problem. */
+export interface IntakeValidationIssue {
+    /** Path of the offending field, e.g. `originalRequest` or `metadata.foo`. */
+    field: string;
+    message: string;
+}
+export declare class IntakeValidationError extends IntakeError {
+    readonly issues: IntakeValidationIssue[];
+    constructor(issues: IntakeValidationIssue[], message?: string);
+}
+export declare class IntakeNotFoundError extends IntakeError {
+    constructor(id: string);
+}
+export declare class IntakeStateTransitionError extends IntakeError {
+    constructor(from: string, to: string);
+}
+/** Raised when mutating a record whose status locks its content. */
+export declare class IntakeStatusLockedError extends IntakeError {
+    constructor(id: string, status: string, action: string);
+}
+/** Raised on optimistic-concurrency version mismatch. */
+export declare class IntakeConflictError extends IntakeError {
+    constructor(id: string, expectedVersion: number, actualVersion: number);
+}
+export declare class IntakeAuthorizationError extends IntakeError {
+    constructor(operation: string, actorId: string, projectId: string);
+}
+/** Raised when the LLM suggestion pipeline fails or returns malformed output. */
+export declare class IntakeSuggestionError extends IntakeError {
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/events.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Requirements Intake — domain event emitter.
+ *
+ * Events carry identifiers and safe metadata only — never a copy of the
+ * user request. Pattern mirrors the Kanban board event emitter.
+ */
+import type { IntakeEvent, IntakeEventName } from './types.js';
+type Listener = (event: IntakeEvent) => void;
+export declare class IntakeEventEmitter {
+    private readonly listeners;
+    /** Publish an event. Listener errors are swallowed so one bad listener cannot break others. */
+    emit(event: IntakeEventName, data: Omit<IntakeEvent, 'event' | 'timestamp'>): void;
+    /** Subscribe; returns a disposer. Past the cap, returns a no-op disposer. */
+    subscribe(listener: Listener): () => void;
+    get listenerCount(): number;
+}
+export {};
+//# sourceMappingURL=events.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Requirements Intake — public surface.
+ *
+ * Collect, preserve, validate, normalize, and submit unstructured software
+ * development requests as structured intake records. Upstream of spec-driven
+ * development; this module never plans, specifies, or implements.
+ */
+export { INTAKE_ID_PREFIX, REQUEST_TYPES, INTAKE_STATUSES, INTAKE_PRIORITIES, INTAKE_FIELD_SOURCES, INTAKE_FIELDS, INTAKE_ATTACHMENT_KINDS, RELATED_RESOURCE_KINDS, INTAKE_QUESTION_STATUSES, SUGGESTION_STATUSES, SUGGESTION_KINDS, MAX_REQUEST_LENGTH, MAX_TITLE_LENGTH, MAX_SUMMARY_LENGTH, MAX_STRING_FIELD_LENGTH, MAX_ARRAY_ITEMS, MAX_ATTACHMENTS, MAX_RELATED_RESOURCES, MAX_METADATA_ENTRIES, MAX_METADATA_BYTES, MAX_ANSWER_LENGTH, MAX_IDEMPOTENCY_KEY_LENGTH, MAX_REFERENCE_LENGTH, MAX_QUESTION_LENGTH, MAX_HISTORY_ENTRIES, MAX_SUGGESTIONS, DEFAULT_INTAKE_QUESTIONS, type RequestType, type IntakeStatus, type IntakePriority, type IntakeFieldSource, type IntakeField, type IntakeAttachmentKind, type RelatedResourceKind, type IntakeQuestionStatus, type SuggestionStatus, type SuggestionKind, type IntakeQuestionTemplate, } from './constants.js';
+export { INTAKE_EVENT_NAMES, type IntakeActor, type IntakeContext, type IntakeAttachment, type RelatedResource, type IntakeAnswer, type IntakeQuestion, type ChangeHistoryEntry, type LlmSuggestionProposal, type RequirementIntakeRecord, type CreateIntakeInput, type IntakeAttachmentInput, type RelatedResourceInput, type IntakeQuestionTemplateInput, type UpdateIntakeInput, type AddAnswerInput, type AttachResourceInput, type IntakeEvent, type IntakeEventName, } from './types.js';
+export { IntakeError, IntakeValidationError, IntakeNotFoundError, IntakeStateTransitionError, IntakeStatusLockedError, IntakeConflictError, IntakeAuthorizationError, IntakeSuggestionError, type IntakeErrorCode, type IntakeValidationIssue, } from './errors.js';
+export { requestTypeSchema, prioritySchema, metadataSchema, attachmentInputSchema, relatedResourceInputSchema, questionTemplateInputSchema, createIntakeSchema, updateIntakeSchema, answerInputSchema, attachResourceInputSchema, normalizeRequestType, isBlank, parseWithIssues, validateCreateInput, validateUpdateInput, validateAnswerInput, validateAttachResourceInput, validateAttachmentInput, validateRelatedResourceInput, validateQuestionTemplateInput, validateFieldSource, deterministicSummary, deterministicTitle, } from './validation.js';
+export { ALLOWED_TRANSITIONS, MUTABLE_STATUSES, canTransition, assertTransition, isMutableStatus, isTerminalStatus, isKnownStatus, } from './lifecycle.js';
+export { buildInitialQuestions, pendingQuestions, upsertQuestion } from './questions.js';
+export { INTAKE_OPERATIONS, AllowAllIntakeAuthorizer, DenyAllIntakeAuthorizer, ProjectMembershipIntakeAuthorizer, type IntakeAuthorizer, type IntakeOperation, type ProjectMembershipIntakeAuthorizerOptions, } from './authorization.js';
+export { NoopIntakeLogger, InMemoryIntakeLogger, type IntakeLogger, type IntakeLogFields, } from './logger.js';
+export { INTAKE_COUNTERS, INTAKE_TIMERS, NoopIntakeMetrics, InMemoryIntakeMetrics, type IntakeCounter, type IntakeTimer, type IntakeMetrics, } from './metrics.js';
+export { IntakeEventEmitter } from './events.js';
+export { RequirementIntakeStore, newIntakeId, type RequirementIntakeStoreOptions, type IntakeIndexEntry, type StoreUpdateOptions, type StoreCreateResult, } from './store.js';
+export { llmSuggestionOutputSchema, validateLlmSuggestionOutput, toProposals, assertSuggestionString, type LlmSuggestionRequest, type LlmSuggestionOutput, type LlmSuggestionGenerator, type NormalizedLlmSuggestion, } from './suggestions.js';
+export { RequirementIntakeService, type RequirementIntakeServiceOptions, type IntakeCreateResult, type IntakeSubmitResult, type IntakeListFilter, } from './service.js';
+//# sourceMappingURL=index.d.ts.map