@wrongstack/requirement-intake 1.0.2 → 1.0.3

package/dist/index.d.ts

@@ -5,18 +5,18 @@
  * 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 { AllowAllIntakeAuthorizer, DenyAllIntakeAuthorizer, INTAKE_OPERATIONS, type IntakeAuthorizer, type IntakeOperation, ProjectMembershipIntakeAuthorizer, type ProjectMembershipIntakeAuthorizerOptions, } from './authorization.js';
+export { DEFAULT_INTAKE_QUESTIONS, INTAKE_ATTACHMENT_KINDS, INTAKE_FIELD_SOURCES, INTAKE_FIELDS, INTAKE_ID_PREFIX, INTAKE_PRIORITIES, INTAKE_QUESTION_STATUSES, INTAKE_STATUSES, type IntakeAttachmentKind, type IntakeField, type IntakeFieldSource, type IntakePriority, type IntakeQuestionStatus, type IntakeQuestionTemplate, type IntakeStatus, MAX_ANSWER_LENGTH, MAX_ARRAY_ITEMS, MAX_ATTACHMENTS, MAX_HISTORY_ENTRIES, MAX_IDEMPOTENCY_KEY_LENGTH, MAX_METADATA_BYTES, MAX_METADATA_ENTRIES, MAX_QUESTION_LENGTH, MAX_REFERENCE_LENGTH, MAX_RELATED_RESOURCES, MAX_REQUEST_LENGTH, MAX_STRING_FIELD_LENGTH, MAX_SUGGESTIONS, MAX_SUMMARY_LENGTH, MAX_TITLE_LENGTH, RELATED_RESOURCE_KINDS, REQUEST_TYPES, type RelatedResourceKind, type RequestType, SUGGESTION_KINDS, SUGGESTION_STATUSES, type SuggestionKind, type SuggestionStatus, } from './constants.js';
+export { IntakeAuthorizationError, IntakeConflictError, IntakeError, type IntakeErrorCode, IntakeNotFoundError, IntakeStateTransitionError, IntakeStatusLockedError, IntakeSuggestionError, IntakeValidationError, type IntakeValidationIssue, } from './errors.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';
-export { VIBE_TAG_REGEX, hasVibeTag, stripVibeTag, deriveVibeState, type VibeProtocolStage, type VibeProtocolState, } from './vibe.js';
+export { ALLOWED_TRANSITIONS, assertTransition, canTransition, isKnownStatus, isMutableStatus, isTerminalStatus, MUTABLE_STATUSES, } from './lifecycle.js';
+export { InMemoryIntakeLogger, type IntakeLogFields, type IntakeLogger, NoopIntakeLogger, } from './logger.js';
+export { INTAKE_COUNTERS, INTAKE_TIMERS, InMemoryIntakeMetrics, type IntakeCounter, type IntakeMetrics, type IntakeTimer, NoopIntakeMetrics, } from './metrics.js';
+export { buildInitialQuestions, pendingQuestions, upsertQuestion } from './questions.js';
+export { type IntakeCreateResult, type IntakeListFilter, type IntakeSubmitResult, RequirementIntakeService, type RequirementIntakeServiceOptions, } from './service.js';
+export { type IntakeIndexEntry, newIntakeId, RequirementIntakeStore, type RequirementIntakeStoreOptions, type StoreCreateResult, type StoreUpdateOptions, } from './store.js';
+export { assertSuggestionString, type LlmSuggestionGenerator, type LlmSuggestionOutput, type LlmSuggestionRequest, llmSuggestionOutputSchema, type NormalizedLlmSuggestion, toProposals, validateLlmSuggestionOutput, } from './suggestions.js';
+export { type AddAnswerInput, type AttachResourceInput, type ChangeHistoryEntry, type CreateIntakeInput, INTAKE_EVENT_NAMES, type IntakeActor, type IntakeAnswer, type IntakeAttachment, type IntakeAttachmentInput, type IntakeContext, type IntakeEvent, type IntakeEventName, type IntakeQuestion, type IntakeQuestionTemplateInput, type LlmSuggestionProposal, type RelatedResource, type RelatedResourceInput, type RequirementIntakeRecord, type UpdateIntakeInput, } from './types.js';
+export { answerInputSchema, attachmentInputSchema, attachResourceInputSchema, createIntakeSchema, deterministicSummary, deterministicTitle, isBlank, metadataSchema, normalizeRequestType, parseWithIssues, prioritySchema, questionTemplateInputSchema, relatedResourceInputSchema, requestTypeSchema, updateIntakeSchema, validateAnswerInput, validateAttachmentInput, validateAttachResourceInput, validateCreateInput, validateFieldSource, validateQuestionTemplateInput, validateRelatedResourceInput, validateUpdateInput, } from './validation.js';
+export { deriveVibeState, hasVibeTag, stripVibeTag, VIBE_TAG_REGEX, type VibeProtocolStage, type VibeProtocolState, } from './vibe.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,3 +1,46 @@
+// src/authorization.ts
+var INTAKE_OPERATIONS = [
+  "create",
+  "read",
+  "list",
+  "update",
+  "answer",
+  "attach",
+  "suggest",
+  "accept_suggestion",
+  "reject_suggestion",
+  "submit",
+  "cancel",
+  "archive"
+];
+var AllowAllIntakeAuthorizer = class {
+  isAllowed(_operation, _ctx, _record) {
+    return true;
+  }
+};
+var DenyAllIntakeAuthorizer = class {
+  isAllowed(_operation, _ctx, _record) {
+    return false;
+  }
+};
+var ProjectMembershipIntakeAuthorizer = class {
+  projectsOf;
+  ownerOnly;
+  constructor(options) {
+    this.projectsOf = options.projectsOf;
+    this.ownerOnly = options.ownerOnlyOperations ?? /* @__PURE__ */ new Set();
+  }
+  async isAllowed(operation, ctx, record) {
+    if (record && record.projectId !== ctx.projectId) return false;
+    const memberships = await this.projectsOf(ctx.id, ctx.type);
+    if (!memberships.has(ctx.projectId)) return false;
+    if (this.ownerOnly.has(operation) && record) {
+      return record.requestedBy === ctx.id;
+    }
+    return true;
+  }
+};
+
 // src/constants.ts
 var INTAKE_ID_PREFIX = "reqi_";
 var ANSWER_ID_PREFIX = "ans_";
@@ -97,16 +140,6 @@ var DEFAULT_INTAKE_QUESTIONS = [
   }
 ];
 
-// src/types.ts
-var INTAKE_EVENT_NAMES = [
-  "RequirementIntakeCreated",
-  "RequirementIntakeUpdated",
-  "RequirementIntakeInformationRequested",
-  "RequirementIntakeSubmitted",
-  "RequirementIntakeCancelled",
-  "RequirementIntakeArchived"
-];
-
 // src/errors.ts
 var IntakeError = class extends Error {
   code;
@@ -176,176 +209,39 @@ var IntakeSuggestionError = class extends IntakeError {
   }
 };
 
-// src/validation.ts
-import { z } from "zod";
-var requestTypeSchema = z.enum(REQUEST_TYPES);
-var prioritySchema = z.enum(INTAKE_PRIORITIES);
-var intakeQuestionStatusSchema = z.enum(INTAKE_QUESTION_STATUSES);
-var fieldSourceSchema = z.enum(["user", "llm", "deterministic", "system"]);
-var httpUrlSchema = z.string().max(MAX_REFERENCE_LENGTH).refine((value) => {
-  try {
-    const url = new URL(value);
-    return url.protocol === "http:" || url.protocol === "https:";
-  } catch {
-    return false;
-  }
-}, "must be a valid http(s) URL");
-var idSchema = z.string().min(1).max(128).refine((value) => value.trim().length > 0, "must not be blank");
-var nonBlankString = (max, label) => z.string().max(max, `${label} exceeds the maximum length of ${max} characters`).refine((value) => value.trim().length > 0, `${label} must not be empty or whitespace-only`);
-var attachmentInputSchema = z.object({
-  name: nonBlankString(200, "attachment name"),
-  kind: z.enum(INTAKE_ATTACHMENT_KINDS),
-  path: z.string().max(MAX_REFERENCE_LENGTH).optional(),
-  url: httpUrlSchema.optional(),
-  sizeBytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
-  mimeType: z.string().max(100).optional()
-}).refine((value) => value.path === void 0 !== (value.url === void 0), {
-  message: "exactly one of path or url is required"
-});
-var relatedResourceInputSchema = z.object({
-  kind: z.enum(RELATED_RESOURCE_KINDS),
-  reference: nonBlankString(MAX_REFERENCE_LENGTH, "related resource reference"),
-  title: z.string().max(200).optional()
-});
-var questionTemplateInputSchema = z.object({
-  field: nonBlankString(64, "question field"),
-  question: nonBlankString(MAX_QUESTION_LENGTH, "question text"),
-  required: z.boolean().optional()
-});
-var metadataSchema = z.record(z.string().max(64), z.unknown()).superRefine((value, ctx) => {
-  const keys = Object.keys(value);
-  if (keys.length > MAX_METADATA_ENTRIES) {
-    ctx.addIssue({
-      code: "custom",
-      path: [],
-      message: `metadata exceeds the maximum of ${MAX_METADATA_ENTRIES} entries`
-    });
+// src/events.ts
+var MAX_LISTENERS = 200;
+var IntakeEventEmitter = class {
+  listeners = /* @__PURE__ */ new Set();
+  /** Publish an event. Listener errors are swallowed so one bad listener cannot break others. */
+  emit(event, data) {
+    const payload = { event, timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...data };
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(payload);
+      } catch {
+      }
+    }
   }
-  let bytes = 0;
-  try {
-    bytes = Buffer.byteLength(JSON.stringify(value), "utf8");
-  } catch {
-    ctx.addIssue({ code: "custom", path: [], message: "metadata must be JSON-serializable" });
-    return;
+  /** Subscribe; returns a disposer. Past the cap, returns a no-op disposer. */
+  subscribe(listener) {
+    if (this.listeners.size >= MAX_LISTENERS) {
+      const message = "Requirement intake event-emitter listener limit reached \u2014 callers must dispose subscriptions";
+      if (typeof process !== "undefined" && typeof process.emitWarning === "function") {
+        process.emitWarning(message, "IntakeEventEmitterWarning");
+      }
+      return () => {
+      };
+    }
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
   }
-  if (bytes > MAX_METADATA_BYTES) {
-    ctx.addIssue({
-      code: "custom",
-      path: [],
-      message: `metadata exceeds the maximum size of ${MAX_METADATA_BYTES} bytes`
-    });
+  get listenerCount() {
+    return this.listeners.size;
   }
-});
-var optionalString = (max) => z.string().max(max).optional();
-var optionalStringArray = z.array(z.string().trim().min(1).max(MAX_STRING_FIELD_LENGTH)).max(MAX_ARRAY_ITEMS).optional();
-var optionalAttachmentArray = z.array(attachmentInputSchema).max(MAX_ATTACHMENTS).optional();
-var optionalRelatedResourceArray = z.array(relatedResourceInputSchema).max(MAX_RELATED_RESOURCES).optional();
-var createIntakeSchema = z.object({
-  projectId: idSchema,
-  originalRequest: nonBlankString(MAX_REQUEST_LENGTH, "originalRequest"),
-  title: optionalString(MAX_TITLE_LENGTH),
-  requestType: z.string().max(64).optional(),
-  priority: prioritySchema.optional(),
-  requestedBy: idSchema,
-  businessGoal: optionalString(MAX_STRING_FIELD_LENGTH),
-  targetUsers: optionalStringArray,
-  expectedOutcome: optionalString(MAX_STRING_FIELD_LENGTH),
-  scopeNotes: optionalString(MAX_STRING_FIELD_LENGTH),
-  constraints: optionalStringArray,
-  providedContext: optionalStringArray,
-  attachments: optionalAttachmentArray,
-  relatedResources: optionalRelatedResourceArray,
-  metadata: metadataSchema.optional(),
-  idempotencyKey: z.string().trim().max(MAX_IDEMPOTENCY_KEY_LENGTH).optional(),
-  knownFields: z.array(z.string().trim().min(1).max(64)).max(MAX_ARRAY_ITEMS).optional(),
-  questions: z.array(questionTemplateInputSchema).max(50).optional()
-}).strict();
-var updateIntakeSchema = z.object({
-  title: optionalString(MAX_TITLE_LENGTH),
-  requestType: z.string().max(64).optional(),
-  priority: prioritySchema.optional(),
-  businessGoal: optionalString(MAX_STRING_FIELD_LENGTH),
-  targetUsers: optionalStringArray,
-  expectedOutcome: optionalString(MAX_STRING_FIELD_LENGTH),
-  scopeNotes: optionalString(MAX_STRING_FIELD_LENGTH),
-  constraints: optionalStringArray,
-  providedContext: optionalStringArray,
-  metadata: metadataSchema.optional()
-}).strict();
-var answerInputSchema = z.object({
-  field: nonBlankString(64, "answer field"),
-  answer: nonBlankString(MAX_ANSWER_LENGTH, "answer").max(
-    MAX_ANSWER_LENGTH,
-    `answer exceeds the maximum length of ${MAX_ANSWER_LENGTH} characters`
-  ),
-  question: z.string().max(MAX_QUESTION_LENGTH).optional()
-});
-var attachResourceInputSchema = z.object({
-  attachment: attachmentInputSchema.optional(),
-  relatedResource: relatedResourceInputSchema.optional()
-}).refine((value) => value.attachment === void 0 !== (value.relatedResource === void 0), {
-  message: "exactly one of attachment or relatedResource must be provided"
-});
-function normalizeRequestType(value) {
-  if (typeof value !== "string") return "unspecified";
-  const trimmed = value.trim().toLowerCase();
-  if (trimmed.length === 0) return "unspecified";
-  const normalized = trimmed.replace(/-/g, "_");
-  if (REQUEST_TYPES.includes(normalized)) return normalized;
-  return "other";
-}
-function isBlank(value) {
-  return value.trim().length === 0;
-}
-function parseWithIssues(schema, data, scope) {
-  const result = schema.safeParse(data);
-  if (result.success) return result.data;
-  const issues = result.error.issues.map((issue) => {
-    const path2 = issue.path.join(".");
-    return {
-      field: path2 === "" ? scope : `${scope}.${path2}`,
-      message: issue.message
-    };
-  });
-  throw new IntakeValidationError(issues);
-}
-function validateCreateInput(data) {
-  return parseWithIssues(createIntakeSchema, data, "createIntake");
-}
-function validateUpdateInput(data) {
-  return parseWithIssues(updateIntakeSchema, data, "updateIntake");
-}
-function validateAnswerInput(data) {
-  return parseWithIssues(answerInputSchema, data, "addAnswer");
-}
-function validateAttachResourceInput(data) {
-  return parseWithIssues(attachResourceInputSchema, data, "attachResource");
-}
-function validateAttachmentInput(data) {
-  return parseWithIssues(attachmentInputSchema, data, "attachment");
-}
-function validateRelatedResourceInput(data) {
-  return parseWithIssues(relatedResourceInputSchema, data, "relatedResource");
-}
-function validateQuestionTemplateInput(data) {
-  return parseWithIssues(questionTemplateInputSchema, data, "question");
-}
-function validateFieldSource(value) {
-  const parsed = fieldSourceSchema.safeParse(value);
-  if (parsed.success) return parsed.data;
-  throw new IntakeValidationError([{ field: "source", message: "invalid field source" }]);
-}
-function deterministicSummary(originalRequest, maxLength = 240) {
-  const collapsed = originalRequest.replace(/\s+/g, " ").trim();
-  if (collapsed.length <= maxLength) return collapsed;
-  return `${collapsed.slice(0, Math.max(0, maxLength - 1)).trimEnd()}\u2026`;
-}
-function deterministicTitle(originalRequest, maxLength = MAX_TITLE_LENGTH) {
-  const firstLine = originalRequest.split(/\r?\n/, 1)[0]?.trim() ?? "";
-  if (firstLine.length === 0) return "Untitled request";
-  if (firstLine.length <= maxLength) return firstLine;
-  return `${firstLine.slice(0, Math.max(0, maxLength - 1)).trimEnd()}\u2026`;
-}
+};
 
 // src/lifecycle.ts
 var ALLOWED_TRANSITIONS = {
@@ -374,93 +270,6 @@ function isKnownStatus(value) {
   return INTAKE_STATUSES.includes(value);
 }
 
-// src/questions.ts
-import { ulid } from "@wrongstack/core/utils";
-var FIELD_TO_INPUT_PROPERTY = {
-  description_scope: () => true,
-  // always answered by the original request
-  business_goal: (input) => input.businessGoal !== void 0 && input.businessGoal.trim().length > 0,
-  target_users: (input) => (input.targetUsers?.length ?? 0) > 0,
-  expected_outcome: (input) => input.expectedOutcome !== void 0 && input.expectedOutcome.trim().length > 0,
-  project_component: (input) => (input.providedContext?.length ?? 0) > 0,
-  constraints: (input) => (input.constraints?.length ?? 0) > 0,
-  related_resources: (input) => (input.relatedResources?.length ?? 0) > 0,
-  priority: (input) => input.priority !== void 0 && input.priority !== "unspecified",
-  attachments: (input) => (input.attachments?.length ?? 0) > 0
-};
-function makeQuestion(template, order, skipped) {
-  return {
-    id: `${QUESTION_ID_PREFIX}${ulid()}`,
-    field: template.field,
-    question: template.question,
-    required: template.required,
-    status: skipped ? "skipped" : "unanswered",
-    order
-  };
-}
-function buildInitialQuestions(input, catalog = DEFAULT_INTAKE_QUESTIONS) {
-  const known = new Set((input.knownFields ?? []).map((field) => field.trim()));
-  return catalog.map((template, index) => {
-    const answeredByInput = FIELD_TO_INPUT_PROPERTY[template.field]?.(input) ?? false;
-    const skipped = answeredByInput || known.has(template.field);
-    return makeQuestion(template, index, skipped);
-  });
-}
-function pendingQuestions(record) {
-  return record.questions.filter((question) => question.status === "unanswered").sort((a, b) => a.order - b.order);
-}
-function upsertQuestion(record, template) {
-  const existing = record.questions.find(
-    (question) => question.field === template.field && question.status !== "skipped"
-  );
-  if (existing) return false;
-  record.questions.push(makeQuestion(template, record.questions.length, false));
-  return true;
-}
-
-// src/authorization.ts
-var INTAKE_OPERATIONS = [
-  "create",
-  "read",
-  "list",
-  "update",
-  "answer",
-  "attach",
-  "suggest",
-  "accept_suggestion",
-  "reject_suggestion",
-  "submit",
-  "cancel",
-  "archive"
-];
-var AllowAllIntakeAuthorizer = class {
-  isAllowed(_operation, _ctx, _record) {
-    return true;
-  }
-};
-var DenyAllIntakeAuthorizer = class {
-  isAllowed(_operation, _ctx, _record) {
-    return false;
-  }
-};
-var ProjectMembershipIntakeAuthorizer = class {
-  projectsOf;
-  ownerOnly;
-  constructor(options) {
-    this.projectsOf = options.projectsOf;
-    this.ownerOnly = options.ownerOnlyOperations ?? /* @__PURE__ */ new Set();
-  }
-  async isAllowed(operation, ctx, record) {
-    if (record && record.projectId !== ctx.projectId) return false;
-    const memberships = await this.projectsOf(ctx.id, ctx.type);
-    if (!memberships.has(ctx.projectId)) return false;
-    if (this.ownerOnly.has(operation) && record) {
-      return record.requestedBy === ctx.id;
-    }
-    return true;
-  }
-};
-
 // src/logger.ts
 var NoopIntakeLogger = class {
   info(_scope, _message, _fields) {
@@ -530,51 +339,64 @@ var InMemoryIntakeMetrics = class {
     bucket.push(milliseconds);
     this.durations.set(timer, bucket);
   }
-  count(counter) {
-    return this.counters.get(counter) ?? 0;
-  }
-  /** Sum of recorded durations for a timer, or undefined when none recorded. */
-  durationSum(timer) {
-    const bucket = this.durations.get(timer);
-    if (!bucket || bucket.length === 0) return void 0;
-    return bucket.reduce((total, value) => total + value, 0);
-  }
-};
-
-// src/events.ts
-var MAX_LISTENERS = 200;
-var IntakeEventEmitter = class {
-  listeners = /* @__PURE__ */ new Set();
-  /** Publish an event. Listener errors are swallowed so one bad listener cannot break others. */
-  emit(event, data) {
-    const payload = { event, timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...data };
-    for (const listener of [...this.listeners]) {
-      try {
-        listener(payload);
-      } catch {
-      }
-    }
-  }
-  /** Subscribe; returns a disposer. Past the cap, returns a no-op disposer. */
-  subscribe(listener) {
-    if (this.listeners.size >= MAX_LISTENERS) {
-      const message = "Requirement intake event-emitter listener limit reached \u2014 callers must dispose subscriptions";
-      if (typeof process !== "undefined" && typeof process.emitWarning === "function") {
-        process.emitWarning(message, "IntakeEventEmitterWarning");
-      }
-      return () => {
-      };
-    }
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
+  count(counter) {
+    return this.counters.get(counter) ?? 0;
   }
-  get listenerCount() {
-    return this.listeners.size;
+  /** Sum of recorded durations for a timer, or undefined when none recorded. */
+  durationSum(timer) {
+    const bucket = this.durations.get(timer);
+    if (!bucket || bucket.length === 0) return void 0;
+    return bucket.reduce((total, value) => total + value, 0);
   }
 };
 
+// src/questions.ts
+import { ulid } from "@wrongstack/core/utils";
+var FIELD_TO_INPUT_PROPERTY = {
+  description_scope: () => true,
+  // always answered by the original request
+  business_goal: (input) => input.businessGoal !== void 0 && input.businessGoal.trim().length > 0,
+  target_users: (input) => (input.targetUsers?.length ?? 0) > 0,
+  expected_outcome: (input) => input.expectedOutcome !== void 0 && input.expectedOutcome.trim().length > 0,
+  project_component: (input) => (input.providedContext?.length ?? 0) > 0,
+  constraints: (input) => (input.constraints?.length ?? 0) > 0,
+  related_resources: (input) => (input.relatedResources?.length ?? 0) > 0,
+  priority: (input) => input.priority !== void 0 && input.priority !== "unspecified",
+  attachments: (input) => (input.attachments?.length ?? 0) > 0
+};
+function makeQuestion(template, order, skipped) {
+  return {
+    id: `${QUESTION_ID_PREFIX}${ulid()}`,
+    field: template.field,
+    question: template.question,
+    required: template.required,
+    status: skipped ? "skipped" : "unanswered",
+    order
+  };
+}
+function buildInitialQuestions(input, catalog = DEFAULT_INTAKE_QUESTIONS) {
+  const known = new Set((input.knownFields ?? []).map((field) => field.trim()));
+  return catalog.map((template, index) => {
+    const answeredByInput = FIELD_TO_INPUT_PROPERTY[template.field]?.(input) ?? false;
+    const skipped = answeredByInput || known.has(template.field);
+    return makeQuestion(template, index, skipped);
+  });
+}
+function pendingQuestions(record) {
+  return record.questions.filter((question) => question.status === "unanswered").sort((a, b) => a.order - b.order);
+}
+function upsertQuestion(record, template) {
+  const existing = record.questions.find(
+    (question) => question.field === template.field && question.status !== "skipped"
+  );
+  if (existing) return false;
+  record.questions.push(makeQuestion(template, record.questions.length, false));
+  return true;
+}
+
+// src/service-helpers.ts
+import { ulid as ulid4 } from "@wrongstack/core/utils";
+
 // src/store.ts
 import { createHash } from "node:crypto";
 import * as fsp from "node:fs/promises";
@@ -794,8 +616,186 @@ function newIntakeId() {
 }
 
 // src/suggestions.ts
-import { z as z2 } from "zod";
 import { ulid as ulid3 } from "@wrongstack/core/utils";
+import { z as z2 } from "zod";
+
+// src/validation.ts
+import { z } from "zod";
+var requestTypeSchema = z.enum(REQUEST_TYPES);
+var prioritySchema = z.enum(INTAKE_PRIORITIES);
+var intakeQuestionStatusSchema = z.enum(INTAKE_QUESTION_STATUSES);
+var fieldSourceSchema = z.enum(["user", "llm", "deterministic", "system"]);
+var httpUrlSchema = z.string().max(MAX_REFERENCE_LENGTH).refine((value) => {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}, "must be a valid http(s) URL");
+var idSchema = z.string().min(1).max(128).refine((value) => value.trim().length > 0, "must not be blank");
+var nonBlankString = (max, label) => z.string().max(max, `${label} exceeds the maximum length of ${max} characters`).refine((value) => value.trim().length > 0, `${label} must not be empty or whitespace-only`);
+var attachmentInputSchema = z.object({
+  name: nonBlankString(200, "attachment name"),
+  kind: z.enum(INTAKE_ATTACHMENT_KINDS),
+  path: z.string().max(MAX_REFERENCE_LENGTH).optional(),
+  url: httpUrlSchema.optional(),
+  sizeBytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
+  mimeType: z.string().max(100).optional()
+}).refine((value) => value.path === void 0 !== (value.url === void 0), {
+  message: "exactly one of path or url is required"
+});
+var relatedResourceInputSchema = z.object({
+  kind: z.enum(RELATED_RESOURCE_KINDS),
+  reference: nonBlankString(MAX_REFERENCE_LENGTH, "related resource reference"),
+  title: z.string().max(200).optional()
+});
+var questionTemplateInputSchema = z.object({
+  field: nonBlankString(64, "question field"),
+  question: nonBlankString(MAX_QUESTION_LENGTH, "question text"),
+  required: z.boolean().optional()
+});
+var metadataSchema = z.record(z.string().max(64), z.unknown()).superRefine((value, ctx) => {
+  const keys = Object.keys(value);
+  if (keys.length > MAX_METADATA_ENTRIES) {
+    ctx.addIssue({
+      code: "custom",
+      path: [],
+      message: `metadata exceeds the maximum of ${MAX_METADATA_ENTRIES} entries`
+    });
+  }
+  let bytes = 0;
+  try {
+    bytes = Buffer.byteLength(JSON.stringify(value), "utf8");
+  } catch {
+    ctx.addIssue({ code: "custom", path: [], message: "metadata must be JSON-serializable" });
+    return;
+  }
+  if (bytes > MAX_METADATA_BYTES) {
+    ctx.addIssue({
+      code: "custom",
+      path: [],
+      message: `metadata exceeds the maximum size of ${MAX_METADATA_BYTES} bytes`
+    });
+  }
+});
+var optionalString = (max) => z.string().max(max).optional();
+var optionalStringArray = z.array(z.string().trim().min(1).max(MAX_STRING_FIELD_LENGTH)).max(MAX_ARRAY_ITEMS).optional();
+var optionalAttachmentArray = z.array(attachmentInputSchema).max(MAX_ATTACHMENTS).optional();
+var optionalRelatedResourceArray = z.array(relatedResourceInputSchema).max(MAX_RELATED_RESOURCES).optional();
+var createIntakeSchema = z.object({
+  projectId: idSchema,
+  originalRequest: nonBlankString(MAX_REQUEST_LENGTH, "originalRequest"),
+  title: optionalString(MAX_TITLE_LENGTH),
+  requestType: z.string().max(64).optional(),
+  priority: prioritySchema.optional(),
+  requestedBy: idSchema,
+  businessGoal: optionalString(MAX_STRING_FIELD_LENGTH),
+  targetUsers: optionalStringArray,
+  expectedOutcome: optionalString(MAX_STRING_FIELD_LENGTH),
+  scopeNotes: optionalString(MAX_STRING_FIELD_LENGTH),
+  constraints: optionalStringArray,
+  providedContext: optionalStringArray,
+  attachments: optionalAttachmentArray,
+  relatedResources: optionalRelatedResourceArray,
+  metadata: metadataSchema.optional(),
+  idempotencyKey: z.string().trim().max(MAX_IDEMPOTENCY_KEY_LENGTH).optional(),
+  knownFields: z.array(z.string().trim().min(1).max(64)).max(MAX_ARRAY_ITEMS).optional(),
+  questions: z.array(questionTemplateInputSchema).max(50).optional(),
+  isVibeMode: z.boolean().optional(),
+  vibeProtocol: z.any().optional()
+}).strict();
+var updateIntakeSchema = z.object({
+  title: optionalString(MAX_TITLE_LENGTH),
+  requestType: z.string().max(64).optional(),
+  priority: prioritySchema.optional(),
+  businessGoal: optionalString(MAX_STRING_FIELD_LENGTH),
+  targetUsers: optionalStringArray,
+  expectedOutcome: optionalString(MAX_STRING_FIELD_LENGTH),
+  scopeNotes: optionalString(MAX_STRING_FIELD_LENGTH),
+  constraints: optionalStringArray,
+  providedContext: optionalStringArray,
+  metadata: metadataSchema.optional(),
+  isVibeMode: z.boolean().optional(),
+  vibeProtocol: z.any().optional()
+}).strict();
+var answerInputSchema = z.object({
+  field: nonBlankString(64, "answer field"),
+  answer: nonBlankString(MAX_ANSWER_LENGTH, "answer").max(
+    MAX_ANSWER_LENGTH,
+    `answer exceeds the maximum length of ${MAX_ANSWER_LENGTH} characters`
+  ),
+  question: z.string().max(MAX_QUESTION_LENGTH).optional()
+});
+var attachResourceInputSchema = z.object({
+  attachment: attachmentInputSchema.optional(),
+  relatedResource: relatedResourceInputSchema.optional()
+}).refine((value) => value.attachment === void 0 !== (value.relatedResource === void 0), {
+  message: "exactly one of attachment or relatedResource must be provided"
+});
+function normalizeRequestType(value) {
+  if (typeof value !== "string") return "unspecified";
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed.length === 0) return "unspecified";
+  const normalized = trimmed.replace(/-/g, "_");
+  if (REQUEST_TYPES.includes(normalized)) return normalized;
+  return "other";
+}
+function isBlank(value) {
+  return value.trim().length === 0;
+}
+function parseWithIssues(schema, data, scope) {
+  const result = schema.safeParse(data);
+  if (result.success) return result.data;
+  const issues = result.error.issues.map((issue) => {
+    const path2 = issue.path.join(".");
+    return {
+      field: path2 === "" ? scope : `${scope}.${path2}`,
+      message: issue.message
+    };
+  });
+  throw new IntakeValidationError(issues);
+}
+function validateCreateInput(data) {
+  return parseWithIssues(createIntakeSchema, data, "createIntake");
+}
+function validateUpdateInput(data) {
+  return parseWithIssues(updateIntakeSchema, data, "updateIntake");
+}
+function validateAnswerInput(data) {
+  return parseWithIssues(answerInputSchema, data, "addAnswer");
+}
+function validateAttachResourceInput(data) {
+  return parseWithIssues(attachResourceInputSchema, data, "attachResource");
+}
+function validateAttachmentInput(data) {
+  return parseWithIssues(attachmentInputSchema, data, "attachment");
+}
+function validateRelatedResourceInput(data) {
+  return parseWithIssues(relatedResourceInputSchema, data, "relatedResource");
+}
+function validateQuestionTemplateInput(data) {
+  return parseWithIssues(questionTemplateInputSchema, data, "question");
+}
+function validateFieldSource(value) {
+  const parsed = fieldSourceSchema.safeParse(value);
+  if (parsed.success) return parsed.data;
+  throw new IntakeValidationError([{ field: "source", message: "invalid field source" }]);
+}
+function deterministicSummary(originalRequest, maxLength = 240) {
+  const collapsed = originalRequest.replace(/\s+/g, " ").trim();
+  if (collapsed.length <= maxLength) return collapsed;
+  return `${collapsed.slice(0, Math.max(0, maxLength - 1)).trimEnd()}\u2026`;
+}
+function deterministicTitle(originalRequest, maxLength = MAX_TITLE_LENGTH) {
+  const newlineIdx = originalRequest.search(/\r?\n/);
+  const firstLine = (newlineIdx >= 0 ? originalRequest.slice(0, newlineIdx) : originalRequest).trim();
+  if (firstLine.length === 0) return "Untitled request";
+  if (firstLine.length <= maxLength) return firstLine;
+  return `${firstLine.slice(0, Math.max(0, maxLength - 1)).trimEnd()}\u2026`;
+}
+
+// src/suggestions.ts
 var outputQuestionSchema = z2.object({
   field: z2.string().trim().min(1).max(64),
   question: z2.string().trim().min(1).max(MAX_QUESTION_LENGTH),
@@ -879,9 +879,6 @@ function assertSuggestionString(value, label, max) {
   return value;
 }
 
-// src/service-helpers.ts
-import { ulid as ulid4 } from "@wrongstack/core/utils";
-
 // src/vibe.ts
 var VIBE_TAG_REGEX = /\[VIBE\]/i;
 function hasVibeTag(text) {
@@ -1786,6 +1783,16 @@ var RequirementIntakeService = class {
     }
   }
 };
+
+// src/types.ts
+var INTAKE_EVENT_NAMES = [
+  "RequirementIntakeCreated",
+  "RequirementIntakeUpdated",
+  "RequirementIntakeInformationRequested",
+  "RequirementIntakeSubmitted",
+  "RequirementIntakeCancelled",
+  "RequirementIntakeArchived"
+];
 export {
   ALLOWED_TRANSITIONS,
   AllowAllIntakeAuthorizer,

package/dist/service.d.ts

@@ -13,13 +13,13 @@
  * The original request is immutable after creation: no API path can change
  * `originalRequest`, and LLM suggestions can never write to it.
  */
-import { type IntakeQuestionTemplate, type IntakeStatus } from './constants.js';
 import type { IntakeAuthorizer } from './authorization.js';
+import { type IntakeQuestionTemplate, type IntakeStatus } from './constants.js';
 import { IntakeEventEmitter } from './events.js';
 import { type IntakeLogger } from './logger.js';
 import { type IntakeMetrics } from './metrics.js';
-import { type LlmSuggestionGenerator } from './suggestions.js';
 import type { RequirementIntakeStore } from './store.js';
+import { type LlmSuggestionGenerator } from './suggestions.js';
 import type { AddAnswerInput, AttachResourceInput, CreateIntakeInput, IntakeContext, IntakeEvent, IntakeQuestion, LlmSuggestionProposal, RequirementIntakeRecord, UpdateIntakeInput } from './types.js';
 export interface RequirementIntakeServiceOptions {
     store: RequirementIntakeStore;

package/dist/validation.d.ts

@@ -128,6 +128,8 @@ export declare const createIntakeSchema: z.ZodObject<{
         question: z.ZodString;
         required: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
+    isVibeMode: z.ZodOptional<z.ZodBoolean>;
+    vibeProtocol: z.ZodOptional<z.ZodAny>;
 }, z.core.$strict>;
 export declare const updateIntakeSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
@@ -146,6 +148,8 @@ export declare const updateIntakeSchema: z.ZodObject<{
     constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     providedContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    isVibeMode: z.ZodOptional<z.ZodBoolean>;
+    vibeProtocol: z.ZodOptional<z.ZodAny>;
 }, z.core.$strict>;
 export declare const answerInputSchema: z.ZodObject<{
     field: z.ZodString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/requirement-intake",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "license": "MIT",
   "description": "WrongStack Requirements Intake — collect, preserve, validate, normalize, and submit unstructured software development requests as structured intake records. Upstream of spec-driven development: it never plans, specifies, or implements.",
   "repository": {
@@ -27,7 +27,7 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@wrongstack/core": "1.0.2",
+    "@wrongstack/core": "1.0.3",
     "zod": "4.4.3"
   },
   "devDependencies": {