@wrongstack/requirement-intake 0.299.0

package/dist/index.js

@@ -0,0 +1,1805 @@
+// src/constants.ts
+var INTAKE_ID_PREFIX = "reqi_";
+var ANSWER_ID_PREFIX = "ans_";
+var ATTACHMENT_ID_PREFIX = "attach_";
+var RELATED_RESOURCE_ID_PREFIX = "relres_";
+var QUESTION_ID_PREFIX = "q_";
+var SUGGESTION_ID_PREFIX = "sug_";
+var REQUEST_TYPES = [
+  "feature",
+  "bug_fix",
+  "refactor",
+  "performance",
+  "security",
+  "ui_change",
+  "api_change",
+  "infrastructure",
+  "migration",
+  "testing",
+  "documentation",
+  "maintenance",
+  "other",
+  "unspecified"
+];
+var INTAKE_STATUSES = [
+  "draft",
+  "collecting_information",
+  "submitted",
+  "cancelled",
+  "archived"
+];
+var INTAKE_PRIORITIES = ["unspecified", "low", "medium", "high", "critical"];
+var INTAKE_FIELD_SOURCES = ["user", "llm", "deterministic", "system"];
+var INTAKE_FIELDS = [
+  "title",
+  "normalized_summary",
+  "request_type",
+  "priority",
+  "business_goal",
+  "target_users",
+  "expected_outcome",
+  "scope_notes",
+  "constraints",
+  "provided_context",
+  "attachments",
+  "related_resources"
+];
+var INTAKE_ATTACHMENT_KINDS = ["file", "image", "document", "link", "other"];
+var RELATED_RESOURCE_KINDS = ["spec", "issue", "pr", "doc", "url", "other"];
+var INTAKE_QUESTION_STATUSES = ["unanswered", "answered", "skipped"];
+var SUGGESTION_STATUSES = ["pending", "accepted", "rejected"];
+var SUGGESTION_KINDS = [
+  "title",
+  "summary",
+  "request_type",
+  "priority",
+  "question",
+  "constraint",
+  "target_user",
+  "outcome"
+];
+var MAX_REQUEST_LENGTH = 1e5;
+var MAX_TITLE_LENGTH = 200;
+var MAX_SUMMARY_LENGTH = 2e3;
+var MAX_STRING_FIELD_LENGTH = 5e3;
+var MAX_ARRAY_ITEMS = 50;
+var MAX_ATTACHMENTS = 20;
+var MAX_RELATED_RESOURCES = 50;
+var MAX_METADATA_ENTRIES = 50;
+var MAX_METADATA_BYTES = 64 * 1024;
+var MAX_ANSWER_LENGTH = 5e4;
+var MAX_IDEMPOTENCY_KEY_LENGTH = 128;
+var MAX_REFERENCE_LENGTH = 500;
+var MAX_QUESTION_LENGTH = 500;
+var MAX_HISTORY_ENTRIES = 200;
+var MAX_SUGGESTIONS = 100;
+var DEFAULT_INTAKE_QUESTIONS = [
+  { field: "description_scope", question: "What should be changed or created?", required: true },
+  { field: "business_goal", question: "What problem should this request solve?", required: true },
+  { field: "target_users", question: "Who will use this functionality?", required: false },
+  { field: "expected_outcome", question: "What outcome is expected?", required: false },
+  {
+    field: "project_component",
+    question: "Which project or component is affected?",
+    required: false
+  },
+  { field: "constraints", question: "Are there known constraints?", required: false },
+  {
+    field: "related_resources",
+    question: "Is there an existing implementation or reference?",
+    required: false
+  },
+  { field: "priority", question: "Is there a desired priority?", required: false },
+  {
+    field: "attachments",
+    question: "Are any files, screenshots, documents, or links relevant?",
+    required: false
+  }
+];
+
+// src/types.ts
+var INTAKE_EVENT_NAMES = [
+  "RequirementIntakeCreated",
+  "RequirementIntakeUpdated",
+  "RequirementIntakeInformationRequested",
+  "RequirementIntakeSubmitted",
+  "RequirementIntakeCancelled",
+  "RequirementIntakeArchived"
+];
+
+// src/errors.ts
+var IntakeError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "IntakeError";
+    this.code = code;
+  }
+};
+var IntakeValidationError = class extends IntakeError {
+  issues;
+  constructor(issues, message) {
+    super(
+      "INTAKE_VALIDATION_ERROR",
+      message ?? `Requirement intake validation failed (${issues.length} issue${issues.length === 1 ? "" : "s"})`
+    );
+    this.name = "IntakeValidationError";
+    this.issues = issues;
+  }
+};
+var IntakeNotFoundError = class extends IntakeError {
+  constructor(id) {
+    super("INTAKE_NOT_FOUND", `Requirement intake record not found: ${id}`);
+    this.name = "IntakeNotFoundError";
+  }
+};
+var IntakeStateTransitionError = class extends IntakeError {
+  constructor(from, to) {
+    super(
+      "INTAKE_INVALID_TRANSITION",
+      `Invalid requirement intake status transition: ${from} \u2192 ${to}`
+    );
+    this.name = "IntakeStateTransitionError";
+  }
+};
+var IntakeStatusLockedError = class extends IntakeError {
+  constructor(id, status, action) {
+    super(
+      "INTAKE_STATUS_LOCKED",
+      `Requirement intake ${id} is ${status} and cannot be modified via ${action}`
+    );
+    this.name = "IntakeStatusLockedError";
+  }
+};
+var IntakeConflictError = class extends IntakeError {
+  constructor(id, expectedVersion, actualVersion) {
+    super(
+      "INTAKE_CONFLICT",
+      `Requirement intake ${id} was modified concurrently (expected version ${expectedVersion}, found ${actualVersion})`
+    );
+    this.name = "IntakeConflictError";
+  }
+};
+var IntakeAuthorizationError = class extends IntakeError {
+  constructor(operation, actorId, projectId) {
+    super(
+      "INTAKE_UNAUTHORIZED",
+      `Actor ${actorId} is not authorized to ${operation} requirement intakes for project ${projectId}`
+    );
+    this.name = "IntakeAuthorizationError";
+  }
+};
+var IntakeSuggestionError = class extends IntakeError {
+  constructor(message, options) {
+    super("INTAKE_SUGGESTION_ERROR", message, options);
+    this.name = "IntakeSuggestionError";
+  }
+};
+
+// 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()
+}).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";
+  if (REQUEST_TYPES.includes(trimmed)) return trimmed;
+  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 = {
+  draft: ["collecting_information", "submitted", "cancelled"],
+  collecting_information: ["submitted", "cancelled"],
+  submitted: ["archived"],
+  cancelled: ["archived"],
+  archived: []
+};
+var MUTABLE_STATUSES = ["draft", "collecting_information"];
+function canTransition(from, to) {
+  return ALLOWED_TRANSITIONS[from]?.includes(to) ?? false;
+}
+function assertTransition(from, to) {
+  if (!canTransition(from, to)) {
+    throw new IntakeStateTransitionError(from, to);
+  }
+}
+function isMutableStatus(status) {
+  return MUTABLE_STATUSES.includes(status);
+}
+function isTerminalStatus(status) {
+  return status === "submitted" || status === "cancelled" || status === "archived";
+}
+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) {
+  }
+  warn(_scope, _message, _fields) {
+  }
+  error(_scope, _message, _fields) {
+  }
+};
+var InMemoryIntakeLogger = class {
+  entries = [];
+  info(scope, message, fields) {
+    this.entries.push({
+      level: "info",
+      scope,
+      message,
+      ...fields !== void 0 ? { fields } : {}
+    });
+  }
+  warn(scope, message, fields) {
+    this.entries.push({
+      level: "warn",
+      scope,
+      message,
+      ...fields !== void 0 ? { fields } : {}
+    });
+  }
+  error(scope, message, fields) {
+    this.entries.push({
+      level: "error",
+      scope,
+      message,
+      ...fields !== void 0 ? { fields } : {}
+    });
+  }
+};
+
+// src/metrics.ts
+var INTAKE_COUNTERS = [
+  "intake.created",
+  "intake.submitted",
+  "intake.cancelled",
+  "intake.archived",
+  "intake.duplicate_create",
+  "intake.duplicate_submit",
+  "intake.validation_failure",
+  "intake.suggestions.requested",
+  "intake.suggestions.succeeded",
+  "intake.suggestions.failed",
+  "intake.unauthorized_attempt"
+];
+var INTAKE_TIMERS = ["intake.time_to_submit"];
+var NoopIntakeMetrics = class {
+  increment(_counter, _by, _labels) {
+  }
+  recordDuration(_timer, _milliseconds) {
+  }
+};
+var InMemoryIntakeMetrics = class {
+  counters = /* @__PURE__ */ new Map();
+  durations = /* @__PURE__ */ new Map();
+  increment(counter, by = 1, _labels) {
+    this.counters.set(counter, (this.counters.get(counter) ?? 0) + by);
+  }
+  recordDuration(timer, milliseconds) {
+    const bucket = this.durations.get(timer) ?? [];
+    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);
+    };
+  }
+  get listenerCount() {
+    return this.listeners.size;
+  }
+};
+
+// src/store.ts
+import { createHash } from "node:crypto";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import {
+  atomicWrite,
+  ensureDir,
+  resolveWstackPaths,
+  ulid as ulid2,
+  withFileLock
+} from "@wrongstack/core/utils";
+var INDEX_PATH = "_index.json";
+var IDEMPOTENCY_PATH = "_idempotency.json";
+function hashIdempotencyKey(key) {
+  return createHash("sha256").update(key, "utf8").digest("hex");
+}
+var RequirementIntakeStore = class {
+  baseDir;
+  indexPath;
+  idempotencyPath;
+  maxIdempotencyEntries;
+  lockTimeoutMs;
+  constructor(options) {
+    this.baseDir = options.baseDir ?? resolveWstackPaths({ projectRoot: process.cwd() }).projectRequirementIntakes;
+    this.indexPath = path.join(this.baseDir, INDEX_PATH);
+    this.idempotencyPath = path.join(this.baseDir, IDEMPOTENCY_PATH);
+    this.maxIdempotencyEntries = options.maxIdempotencyEntries ?? 1e4;
+    this.lockTimeoutMs = options.lockTimeoutMs ?? 15e3;
+  }
+  get directory() {
+    return this.baseDir;
+  }
+  recordPath(id) {
+    return path.join(this.baseDir, `${id}.json`);
+  }
+  // -------------------------------------------------------------------------
+  // Reads (lock-free — atomic writes make a torn read impossible)
+  // -------------------------------------------------------------------------
+  async load(id) {
+    try {
+      const raw = await fsp.readFile(this.recordPath(id), "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async exists(id) {
+    try {
+      await fsp.access(this.recordPath(id));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** List full records for a project, newest-updated first. */
+  async list(projectId, filter) {
+    const entries = await this.listIndex(projectId, filter);
+    const records = await Promise.all(entries.map((entry) => this.load(entry.id)));
+    return records.filter((record) => record !== null);
+  }
+  /** Cheap listing via the index — no record file reads. */
+  async listIndex(projectId, filter) {
+    const index = await this.readIndex();
+    const statuses = filter?.statuses ? new Set(filter.statuses) : void 0;
+    return index.entries.filter((entry) => projectId === void 0 || entry.projectId === projectId).filter((entry) => statuses === void 0 || statuses.has(entry.status)).sort((a, b) => b.updatedAt - a.updatedAt);
+  }
+  async findByIdempotencyKey(key) {
+    const map = await this.readIdempotency();
+    const entry = map.entries[hashIdempotencyKey(key)];
+    if (!entry) return null;
+    return this.load(entry.intakeId);
+  }
+  // -------------------------------------------------------------------------
+  // Writes (serialized per file)
+  // -------------------------------------------------------------------------
+  /**
+   * Persist a new record. When `idempotencyKey` is given, a second create
+   * with the same key returns the existing record instead of duplicating it.
+   */
+  async create(record, idempotencyKey) {
+    await ensureDir(this.baseDir);
+    if (idempotencyKey !== void 0 && idempotencyKey.trim().length > 0) {
+      const key = idempotencyKey.trim();
+      return withFileLock(
+        this.idempotencyPath,
+        async () => {
+          const existing = await this.findByIdempotencyKey(key);
+          if (existing) {
+            return { record: existing, created: false, idempotent: true };
+          }
+          const map = await this.readIdempotency();
+          map.entries[hashIdempotencyKey(key)] = {
+            intakeId: record.id,
+            createdAt: record.createdAt
+          };
+          await this.pruneIdempotency(map);
+          await atomicWrite(this.idempotencyPath, JSON.stringify(map, null, 2), { mode: 384 });
+          const toWrite = { ...record, idempotencyKey: key };
+          await this.writeRecord(toWrite);
+          await this.updateIndexFor(toWrite);
+          return { record: toWrite, created: true, idempotent: false };
+        },
+        { timeoutMs: this.lockTimeoutMs }
+      );
+    }
+    await this.writeRecord(record);
+    await this.updateIndexFor(record);
+    return { record, created: true, idempotent: false };
+  }
+  /**
+   * Read-modify-write with optimistic concurrency. `mutate` receives a
+   * mutable copy; the store bumps `version`, refreshes `updatedAt`, appends
+   * the history entry, and persists atomically under the record lock.
+   */
+  async update(id, options, mutate) {
+    return withFileLock(
+      this.recordPath(id),
+      async () => {
+        const current = await this.load(id);
+        if (!current) throw new IntakeNotFoundError(id);
+        if (options.expectedVersion !== void 0 && current.version !== options.expectedVersion) {
+          throw new IntakeConflictError(id, options.expectedVersion, current.version);
+        }
+        const next = structuredClone(current);
+        await mutate(next);
+        next.version = current.version + 1;
+        next.updatedAt = Date.now();
+        this.appendHistory(next, options);
+        await this.writeRecord(next);
+        await this.updateIndexFor(next);
+        return next;
+      },
+      { timeoutMs: this.lockTimeoutMs }
+    );
+  }
+  // -------------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------------
+  async writeRecord(record) {
+    await atomicWrite(this.recordPath(record.id), JSON.stringify(record, null, 2), { mode: 384 });
+  }
+  appendHistory(record, options) {
+    const entry = {
+      at: Date.now(),
+      actor: options.actorId,
+      actorType: options.actorType,
+      action: options.action ?? "updated",
+      fields: options.fields,
+      from: options.from,
+      to: options.to
+    };
+    record.history.push(entry);
+    if (record.history.length > MAX_HISTORY_ENTRIES) {
+      record.history = record.history.slice(record.history.length - MAX_HISTORY_ENTRIES);
+    }
+  }
+  async readIndex() {
+    try {
+      const raw = await fsp.readFile(this.indexPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed?.version === 1 && Array.isArray(parsed.entries)) return parsed;
+    } catch {
+    }
+    return { version: 1, entries: [] };
+  }
+  async updateIndexFor(record) {
+    return withFileLock(
+      this.indexPath,
+      async () => {
+        const index = await this.readIndex();
+        const entry = {
+          id: record.id,
+          projectId: record.projectId,
+          title: record.title,
+          status: record.status,
+          requestType: record.requestType,
+          priority: record.priority,
+          requestedBy: record.requestedBy,
+          updatedAt: record.updatedAt,
+          createdAt: record.createdAt
+        };
+        const position = index.entries.findIndex((candidate) => candidate.id === record.id);
+        if (position >= 0) {
+          index.entries[position] = entry;
+        } else {
+          index.entries.push(entry);
+        }
+        await atomicWrite(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
+      },
+      { timeoutMs: this.lockTimeoutMs }
+    );
+  }
+  async readIdempotency() {
+    try {
+      const raw = await fsp.readFile(this.idempotencyPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed?.version === 1 && parsed.entries && typeof parsed.entries === "object")
+        return parsed;
+    } catch {
+    }
+    return { version: 1, entries: {} };
+  }
+  async pruneIdempotency(map) {
+    const entries = Object.entries(map.entries);
+    if (entries.length <= this.maxIdempotencyEntries) return;
+    entries.sort((a, b) => a[1].createdAt - b[1].createdAt);
+    const keep = new Set(
+      entries.slice(entries.length - this.maxIdempotencyEntries).map(([key]) => key)
+    );
+    for (const key of Object.keys(map.entries)) {
+      if (!keep.has(key)) delete map.entries[key];
+    }
+  }
+};
+function newIntakeId() {
+  return `reqi_${ulid2()}`;
+}
+
+// src/suggestions.ts
+import { z as z2 } from "zod";
+import { ulid as ulid3 } from "@wrongstack/core/utils";
+var outputQuestionSchema = z2.object({
+  field: z2.string().trim().min(1).max(64),
+  question: z2.string().trim().min(1).max(MAX_QUESTION_LENGTH),
+  required: z2.boolean().optional()
+});
+var outputStringArraySchema = z2.array(z2.string().trim().min(1).max(MAX_STRING_FIELD_LENGTH)).max(MAX_ARRAY_ITEMS);
+var llmSuggestionOutputSchema = z2.object({
+  suggested_title: z2.string().trim().min(1).max(MAX_TITLE_LENGTH).optional(),
+  normalized_summary: z2.string().trim().min(1).max(MAX_SUMMARY_LENGTH).optional(),
+  suggested_request_type: z2.string().trim().min(1).max(64).optional(),
+  suggested_priority: z2.string().trim().min(1).max(32).optional(),
+  extracted_constraints: outputStringArraySchema.optional(),
+  extracted_target_users: outputStringArraySchema.optional(),
+  suggested_outcome: z2.string().trim().min(1).max(MAX_ANSWER_LENGTH).optional(),
+  suggested_questions: z2.array(outputQuestionSchema).max(20).optional()
+});
+function validateLlmSuggestionOutput(raw) {
+  const parsed = llmSuggestionOutputSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((issue) => issue.message).join("; ");
+    throw new IntakeSuggestionError(`Malformed LLM suggestion output: ${issues}`);
+  }
+  const value = parsed.data;
+  const requestType = value.suggested_request_type ? normalizeRequestType(value.suggested_request_type) : void 0;
+  const priority = value.suggested_priority ? INTAKE_PRIORITIES.includes(value.suggested_priority) ? value.suggested_priority : void 0 : void 0;
+  return {
+    suggestedTitle: value.suggested_title,
+    normalizedSummary: value.normalized_summary,
+    suggestedRequestType: requestType,
+    suggestedPriority: priority,
+    extractedConstraints: value.extracted_constraints ?? [],
+    extractedTargetUsers: value.extracted_target_users ?? [],
+    suggestedOutcome: value.suggested_outcome,
+    suggestedQuestions: value.suggested_questions ?? []
+  };
+}
+function proposal(kind, field, value) {
+  return {
+    id: `${SUGGESTION_ID_PREFIX}${ulid3()}`,
+    kind,
+    field,
+    value,
+    status: "pending",
+    createdAt: Date.now()
+  };
+}
+function toProposals(suggestion) {
+  const proposals = [];
+  if (suggestion.suggestedTitle !== void 0) {
+    proposals.push(proposal("title", "title", suggestion.suggestedTitle));
+  }
+  if (suggestion.normalizedSummary !== void 0) {
+    proposals.push(proposal("summary", "normalized_summary", suggestion.normalizedSummary));
+  }
+  if (suggestion.suggestedRequestType !== void 0) {
+    proposals.push(proposal("request_type", "request_type", suggestion.suggestedRequestType));
+  }
+  if (suggestion.suggestedPriority !== void 0) {
+    proposals.push(proposal("priority", "priority", suggestion.suggestedPriority));
+  }
+  for (const constraint of suggestion.extractedConstraints) {
+    proposals.push(proposal("constraint", "constraints", constraint));
+  }
+  for (const targetUser of suggestion.extractedTargetUsers) {
+    proposals.push(proposal("target_user", "target_users", targetUser));
+  }
+  if (suggestion.suggestedOutcome !== void 0) {
+    proposals.push(proposal("outcome", "expected_outcome", suggestion.suggestedOutcome));
+  }
+  for (const question of suggestion.suggestedQuestions) {
+    proposals.push(proposal("question", question.field, question));
+  }
+  return proposals;
+}
+function assertSuggestionString(value, label, max) {
+  if (typeof value !== "string" || value.trim().length === 0 || value.length > max) {
+    throw new IntakeValidationError([
+      { field: `suggestion.${label}`, message: `invalid ${label} suggestion value` }
+    ]);
+  }
+  return value;
+}
+
+// src/service.ts
+import { ulid as ulid4 } from "@wrongstack/core/utils";
+var ANSWER_FIELD_MAPPING = {
+  business_goal: {
+    set: (record, value) => {
+      record.businessGoal = value;
+    }
+  },
+  expected_outcome: {
+    set: (record, value) => {
+      record.expectedOutcome = value;
+    }
+  },
+  scope_notes: {
+    set: (record, value) => {
+      record.scopeNotes = value;
+    }
+  },
+  description_scope: {
+    set: (record, value) => {
+      record.scopeNotes = value;
+    }
+  },
+  target_users: {
+    set: (record, value) => {
+      appendItems(record.targetUsers, value);
+    }
+  },
+  constraints: {
+    set: (record, value) => {
+      appendItems(record.constraints, value);
+    }
+  },
+  provided_context: {
+    set: (record, value) => {
+      appendItems(record.providedContext, value);
+    }
+  },
+  project_component: {
+    set: (record, value) => {
+      appendItems(record.providedContext, value);
+    }
+  },
+  priority: {
+    set: (record, value) => {
+      const trimmed = value.trim().toLowerCase();
+      if (INTAKE_PRIORITIES.includes(trimmed)) {
+        record.priority = trimmed;
+        record.fieldSources.priority = "user";
+      }
+    }
+  }
+};
+function appendItems(target, value) {
+  const items = value.split(/\r?\n/).map((item) => item.trim()).filter((item) => item.length > 0);
+  const remaining = Math.max(0, MAX_ARRAY_ITEMS - target.length);
+  target.push(...items.slice(0, remaining));
+}
+var RequirementIntakeService = class {
+  store;
+  authorizer;
+  generator;
+  emitter;
+  logger;
+  metrics;
+  catalog;
+  constructor(options) {
+    this.store = options.store;
+    this.authorizer = options.authorizer;
+    this.generator = options.generator;
+    this.emitter = options.emitter ?? new IntakeEventEmitter();
+    this.logger = options.logger ?? new NoopIntakeLogger();
+    this.metrics = options.metrics ?? new InMemoryIntakeMetrics();
+    this.catalog = options.questions ?? DEFAULT_INTAKE_QUESTIONS;
+  }
+  /** Subscribe to domain events. Returns a disposer. */
+  subscribe(listener) {
+    return this.emitter.subscribe(listener);
+  }
+  // -------------------------------------------------------------------------
+  // Creation
+  // -------------------------------------------------------------------------
+  async createIntake(input, ctx) {
+    const validated = this.guardValidation(() => validateCreateInput(input));
+    if (validated.projectId !== ctx.projectId) {
+      throw new IntakeAuthorizationError("create", ctx.id, validated.projectId);
+    }
+    await this.authorize("create", ctx);
+    if (validated.idempotencyKey !== void 0 && validated.idempotencyKey.trim().length > 0) {
+      const existing = await this.store.findByIdempotencyKey(validated.idempotencyKey);
+      if (existing) {
+        if (existing.projectId !== ctx.projectId) {
+          throw new IntakeValidationError([
+            {
+              field: "idempotencyKey",
+              message: "idempotency key already used for a different project"
+            }
+          ]);
+        }
+        this.metrics.increment("intake.duplicate_create");
+        this.logger.info("intake", "intake.duplicate_create", {
+          intakeId: existing.id,
+          projectId: existing.projectId,
+          actorId: ctx.id
+        });
+        return { record: existing, created: false, idempotent: true };
+      }
+    }
+    const now = Date.now();
+    const record = this.buildNewRecord(validated, ctx, now);
+    const result = await this.store.create(record, validated.idempotencyKey?.trim());
+    this.logger.info("intake", "intake.created", {
+      intakeId: result.record.id,
+      projectId: result.record.projectId,
+      actorId: ctx.id
+    });
+    this.metrics.increment("intake.created");
+    this.emit("RequirementIntakeCreated", {
+      intakeId: result.record.id,
+      projectId: result.record.projectId,
+      actorId: ctx.id,
+      actorType: ctx.type,
+      status: result.record.status
+    });
+    return result;
+  }
+  // -------------------------------------------------------------------------
+  // Reads
+  // -------------------------------------------------------------------------
+  async getIntake(id, ctx) {
+    const record = await this.store.load(id);
+    if (!record) return null;
+    await this.authorize("read", ctx, record);
+    return record;
+  }
+  async listIntakes(projectId, ctx, filter) {
+    if (projectId !== ctx.projectId) {
+      throw new IntakeAuthorizationError("list", ctx.id, projectId);
+    }
+    await this.authorize("list", ctx);
+    return this.store.list(projectId, filter);
+  }
+  async pendingQuestions(id, ctx) {
+    const record = await this.requireRecord(id, ctx, "read");
+    return pendingQuestions(record);
+  }
+  // -------------------------------------------------------------------------
+  // Draft editing
+  // -------------------------------------------------------------------------
+  async updateIntake(id, patch, ctx, expectedVersion) {
+    const record = await this.requireRecord(id, ctx, "update");
+    this.assertMutable(record, "updateIntake");
+    const validated = this.guardValidation(() => validateUpdateInput(patch));
+    const changedKeys = Object.keys(validated);
+    if (changedKeys.length === 0) return record;
+    if (validated.title !== void 0 && validated.title.trim().length === 0) {
+      throw new IntakeValidationError([{ field: "title", message: "title must not be blank" }]);
+    }
+    return this.store.update(id, this.updateMeta(ctx, "updated", changedKeys, expectedVersion), (next) => {
+      if (validated.title !== void 0) {
+        next.title = validated.title.trim();
+        next.fieldSources.title = "user";
+      }
+      if (validated.requestType !== void 0) {
+        next.requestType = normalizeRequestType(validated.requestType);
+        next.fieldSources.request_type = "user";
+      }
+      if (validated.priority !== void 0) {
+        next.priority = validated.priority;
+        next.fieldSources.priority = "user";
+      }
+      applyOptionalString(next, "businessGoal", validated.businessGoal);
+      applyOptionalString(next, "expectedOutcome", validated.expectedOutcome);
+      applyOptionalString(next, "scopeNotes", validated.scopeNotes);
+      if (validated.targetUsers !== void 0) next.targetUsers = [...validated.targetUsers];
+      if (validated.constraints !== void 0) next.constraints = [...validated.constraints];
+      if (validated.providedContext !== void 0)
+        next.providedContext = [...validated.providedContext];
+      if (validated.metadata !== void 0) next.metadata = validated.metadata;
+      markUserSources(next, changedKeys);
+    }).then((updated) => {
+      this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
+      return updated;
+    });
+  }
+  async addAnswer(id, input, ctx, expectedVersion) {
+    const record = await this.requireRecord(id, ctx, "answer");
+    this.assertMutable(record, "addAnswer");
+    const validated = this.guardValidation(() => validateAnswerInput(input));
+    this.assertAnswerField(validated.field);
+    return this.store.update(
+      id,
+      this.updateMeta(ctx, "answer_added", [validated.field], expectedVersion),
+      (next) => {
+        const question = next.questions.find((candidate) => candidate.field === validated.field);
+        const answer = {
+          id: `${ANSWER_ID_PREFIX}${ulid4()}`,
+          field: validated.field,
+          question: validated.question ?? question?.question ?? validated.field,
+          answer: validated.answer,
+          source: "user",
+          answeredBy: ctx.id,
+          answeredAt: Date.now()
+        };
+        next.answers.push(answer);
+        if (question && question.status === "unanswered") {
+          question.status = "answered";
+          question.answer = validated.answer;
+        }
+        ANSWER_FIELD_MAPPING[validated.field]?.set(next, validated.answer);
+        if (INTAKE_FIELDS.includes(validated.field)) {
+          next.fieldSources[validated.field] = "user";
+        }
+      }
+    ).then((updated) => {
+      this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
+      return updated;
+    });
+  }
+  async updateAnswer(id, answerId, patch, ctx, expectedVersion) {
+    const record = await this.requireRecord(id, ctx, "answer");
+    this.assertMutable(record, "updateAnswer");
+    const validated = this.guardValidation(
+      () => validateAnswerInput({
+        field: record.answers.find((a) => a.id === answerId)?.field ?? "unknown",
+        answer: patch.answer
+      })
+    );
+    return this.store.update(id, this.updateMeta(ctx, "answer_updated", [answerId], expectedVersion), (next) => {
+      const answer = next.answers.find((candidate) => candidate.id === answerId);
+      if (!answer) {
+        throw new IntakeValidationError([
+          { field: "answerId", message: `answer not found: ${answerId}` }
+        ]);
+      }
+      answer.answer = validated.answer;
+      answer.answeredAt = Date.now();
+      const question = next.questions.find((candidate) => candidate.field === answer.field);
+      if (question) {
+        question.answer = validated.answer;
+        question.status = "answered";
+      }
+    }).then((updated) => {
+      this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
+      return updated;
+    });
+  }
+  async attachResource(id, input, ctx, expectedVersion) {
+    const record = await this.requireRecord(id, ctx, "attach");
+    this.assertMutable(record, "attachResource");
+    const validated = this.guardValidation(() => validateAttachResourceInput(input));
+    const now = Date.now();
+    if (validated.attachment !== void 0) {
+      if (record.attachments.length >= MAX_ATTACHMENTS) {
+        throw new IntakeValidationError([
+          { field: "attachments", message: `maximum of ${MAX_ATTACHMENTS} attachments reached` }
+        ]);
+      }
+      return this.store.update(
+        id,
+        this.updateMeta(ctx, "attachment_added", ["attachments"], expectedVersion),
+        (next) => {
+          const attachment = {
+            id: `${ATTACHMENT_ID_PREFIX}${ulid4()}`,
+            name: validated.attachment.name,
+            kind: validated.attachment.kind,
+            path: validated.attachment?.path,
+            url: validated.attachment?.url,
+            sizeBytes: validated.attachment?.sizeBytes,
+            mimeType: validated.attachment?.mimeType,
+            source: "user",
+            addedBy: ctx.id,
+            addedAt: now
+          };
+          next.attachments.push(attachment);
+          next.fieldSources.attachments = "user";
+          markQuestionAnswered(next, "attachments", attachment.name);
+        }
+      ).then((updated) => {
+        this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
+        return updated;
+      });
+    }
+    if (record.relatedResources.length >= MAX_RELATED_RESOURCES) {
+      throw new IntakeValidationError([
+        {
+          field: "relatedResources",
+          message: `maximum of ${MAX_RELATED_RESOURCES} related resources reached`
+        }
+      ]);
+    }
+    return this.store.update(
+      id,
+      this.updateMeta(ctx, "related_resource_added", ["related_resources"], expectedVersion),
+      (next) => {
+        const resource = {
+          id: `${RELATED_RESOURCE_ID_PREFIX}${ulid4()}`,
+          kind: validated.relatedResource.kind,
+          reference: validated.relatedResource.reference,
+          title: validated.relatedResource?.title,
+          source: "user",
+          addedBy: ctx.id,
+          addedAt: now
+        };
+        next.relatedResources.push(resource);
+        next.fieldSources.related_resources = "user";
+        markQuestionAnswered(next, "related_resources", resource.reference);
+      }
+    ).then((updated) => {
+      this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
+      return updated;
+    });
+  }
+  // -------------------------------------------------------------------------
+  // LLM suggestions (always proposals)
+  // -------------------------------------------------------------------------
+  async generateSuggestions(id, ctx, focus) {
+    const record = await this.requireRecord(id, ctx, "suggest");
+    this.assertMutable(record, "generateSuggestions");
+    if (!this.generator) {
+      throw new IntakeSuggestionError("No LLM suggestion generator is configured on this service");
+    }
+    this.metrics.increment("intake.suggestions.requested");
+    let output;
+    try {
+      output = await this.generator.generate({ record, focus });
+    } catch (error) {
+      this.metrics.increment("intake.suggestions.failed");
+      this.logger.error("intake", "intake.suggestions.failed", {
+        intakeId: record.id,
+        projectId: record.projectId,
+        actorId: ctx.id
+      });
+      throw new IntakeSuggestionError("LLM suggestion generation failed", { cause: error });
+    }
+    let proposals;
+    try {
+      proposals = toProposals(validateLlmSuggestionOutput(output));
+    } catch (error) {
+      this.metrics.increment("intake.suggestions.failed");
+      throw error instanceof IntakeSuggestionError ? error : new IntakeSuggestionError("LLM suggestion output could not be validated", {
+        cause: error
+      });
+    }
+    if (proposals.length === 0) {
+      this.metrics.increment("intake.suggestions.failed");
+      throw new IntakeSuggestionError("LLM suggestion output contained no usable proposals");
+    }
+    const hadQuestions = proposals.some((proposal2) => proposal2.kind === "question");
+    const previousStatus = record.status;
+    const nextStatus = previousStatus === "draft" ? "collecting_information" : previousStatus;
+    const updated = await this.store.update(
+      id,
+      {
+        actorId: ctx.id,
+        actorType: ctx.type,
+        action: hadQuestions ? "information_requested" : "suggestions_added",
+        from: previousStatus === nextStatus ? void 0 : previousStatus,
+        to: previousStatus === nextStatus ? void 0 : nextStatus
+      },
+      (next) => {
+        next.llmSuggestions.push(...proposals);
+        if (next.llmSuggestions.length > MAX_SUGGESTIONS) {
+          next.llmSuggestions = next.llmSuggestions.slice(
+            next.llmSuggestions.length - MAX_SUGGESTIONS
+          );
+        }
+        if (previousStatus === "draft" && nextStatus === "collecting_information") {
+          next.status = nextStatus;
+        }
+      }
+    );
+    this.metrics.increment("intake.suggestions.succeeded");
+    this.logger.info("intake", "intake.suggestions.succeeded", {
+      intakeId: updated.id,
+      projectId: updated.projectId,
+      actorId: ctx.id,
+      count: proposals.length
+    });
+    this.emit(hadQuestions ? "RequirementIntakeInformationRequested" : "RequirementIntakeUpdated", {
+      intakeId: updated.id,
+      projectId: updated.projectId,
+      actorId: ctx.id,
+      actorType: ctx.type,
+      previousStatus,
+      status: updated.status
+    });
+    return proposals;
+  }
+  async acceptSuggestion(id, proposalId, ctx, expectedVersion) {
+    const record = await this.requireRecord(id, ctx, "accept_suggestion");
+    this.assertMutable(record, "acceptSuggestion");
+    const proposal2 = this.findSuggestion(record, proposalId);
+    if (proposal2.status !== "pending") {
+      throw new IntakeValidationError([
+        { field: "suggestionId", message: `suggestion is already ${proposal2.status}` }
+      ]);
+    }
+    return this.store.update(
+      id,
+      this.updateMeta(ctx, "suggestion_accepted", [proposal2.kind], expectedVersion),
+      (next) => {
+        const target = next.llmSuggestions.find((candidate) => candidate.id === proposalId);
+        if (!target) {
+          throw new IntakeValidationError([
+            { field: "suggestionId", message: `suggestion not found: ${proposalId}` }
+          ]);
+        }
+        this.applyProposal(next, target);
+        target.status = "accepted";
+        target.resolvedAt = Date.now();
+      }
+    ).then((updated) => {
+      this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
+      return updated;
+    });
+  }
+  async rejectSuggestion(id, proposalId, ctx, expectedVersion) {
+    const record = await this.requireRecord(id, ctx, "reject_suggestion");
+    this.assertMutable(record, "rejectSuggestion");
+    this.findSuggestion(record, proposalId);
+    return this.store.update(
+      id,
+      this.updateMeta(ctx, "suggestion_rejected", [proposalId], expectedVersion),
+      (next) => {
+        const target = next.llmSuggestions.find((candidate) => candidate.id === proposalId);
+        if (!target) {
+          throw new IntakeValidationError([
+            { field: "suggestionId", message: `suggestion not found: ${proposalId}` }
+          ]);
+        }
+        if (target.status !== "pending") {
+          throw new IntakeValidationError([
+            { field: "suggestionId", message: `suggestion is already ${target.status}` }
+          ]);
+        }
+        target.status = "rejected";
+        target.resolvedAt = Date.now();
+      }
+    ).then((updated) => {
+      this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
+      return updated;
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  async submitIntake(id, ctx, expectedVersion) {
+    const record = await this.requireRecord(id, ctx, "submit");
+    if (record.status === "submitted") {
+      this.metrics.increment("intake.duplicate_submit");
+      return { record, idempotent: true };
+    }
+    assertTransition(record.status, "submitted");
+    this.assertSubmitReady(record);
+    const now = Date.now();
+    try {
+      const updated = await this.store.update(
+        id,
+        {
+          actorId: ctx.id,
+          actorType: ctx.type,
+          action: "submitted",
+          from: record.status,
+          to: "submitted",
+          expectedVersion: expectedVersion ?? record.version
+        },
+        (next) => {
+          next.status = "submitted";
+          next.submittedAt = now;
+          next.submittedBy = ctx.id;
+          next.submittedByType = ctx.type;
+        }
+      );
+      this.metrics.increment("intake.submitted");
+      this.metrics.recordDuration("intake.time_to_submit", now - updated.createdAt);
+      this.logger.info("intake", "intake.submitted", {
+        intakeId: updated.id,
+        projectId: updated.projectId,
+        actorId: ctx.id
+      });
+      this.emit("RequirementIntakeSubmitted", {
+        intakeId: updated.id,
+        projectId: updated.projectId,
+        actorId: ctx.id,
+        actorType: ctx.type,
+        previousStatus: record.status,
+        status: "submitted"
+      });
+      return { record: updated, idempotent: false };
+    } catch (error) {
+      if (error instanceof IntakeConflictError) {
+        const latest = await this.store.load(id);
+        if (latest && latest.status === "submitted") {
+          this.metrics.increment("intake.duplicate_submit");
+          return { record: latest, idempotent: true };
+        }
+      }
+      throw error;
+    }
+  }
+  async cancelIntake(id, ctx, reason, expectedVersion) {
+    const record = await this.requireRecord(id, ctx, "cancel");
+    assertTransition(record.status, "cancelled");
+    const updated = await this.store.update(
+      id,
+      {
+        actorId: ctx.id,
+        actorType: ctx.type,
+        action: "cancelled",
+        from: record.status,
+        to: "cancelled",
+        expectedVersion
+      },
+      (next) => {
+        next.status = "cancelled";
+        next.cancelledAt = Date.now();
+        next.cancelledReason = reason?.trim() || void 0;
+      }
+    );
+    this.metrics.increment("intake.cancelled");
+    this.logger.info("intake", "intake.cancelled", {
+      intakeId: updated.id,
+      projectId: updated.projectId,
+      actorId: ctx.id
+    });
+    this.emit("RequirementIntakeCancelled", {
+      intakeId: updated.id,
+      projectId: updated.projectId,
+      actorId: ctx.id,
+      actorType: ctx.type,
+      previousStatus: record.status,
+      status: "cancelled"
+    });
+    return updated;
+  }
+  async archiveIntake(id, ctx, expectedVersion) {
+    const record = await this.requireRecord(id, ctx, "archive");
+    assertTransition(record.status, "archived");
+    const updated = await this.store.update(
+      id,
+      {
+        actorId: ctx.id,
+        actorType: ctx.type,
+        action: "archived",
+        from: record.status,
+        to: "archived",
+        expectedVersion
+      },
+      (next) => {
+        next.status = "archived";
+        next.archivedAt = Date.now();
+      }
+    );
+    this.metrics.increment("intake.archived");
+    this.logger.info("intake", "intake.archived", {
+      intakeId: updated.id,
+      projectId: updated.projectId,
+      actorId: ctx.id
+    });
+    this.emit("RequirementIntakeArchived", {
+      intakeId: updated.id,
+      projectId: updated.projectId,
+      actorId: ctx.id,
+      actorType: ctx.type,
+      previousStatus: record.status,
+      status: "archived"
+    });
+    return updated;
+  }
+  // -------------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------------
+  buildNewRecord(input, ctx, now) {
+    const titleProvided = input.title !== void 0 && input.title.trim().length > 0;
+    const title = titleProvided ? input.title.trim() : deterministicTitle(input.originalRequest);
+    const requestType = normalizeRequestType(input.requestType);
+    const idempotencyKey = input.idempotencyKey?.trim();
+    const attachments = (input.attachments ?? []).map((attachment) => ({
+      id: `${ATTACHMENT_ID_PREFIX}${ulid4()}`,
+      name: attachment.name,
+      kind: attachment.kind,
+      path: attachment.path,
+      url: attachment.url,
+      sizeBytes: attachment.sizeBytes,
+      mimeType: attachment.mimeType,
+      source: "user",
+      addedBy: ctx.id,
+      addedAt: now
+    }));
+    const relatedResources = (input.relatedResources ?? []).map((resource) => ({
+      id: `${RELATED_RESOURCE_ID_PREFIX}${ulid4()}`,
+      kind: resource.kind,
+      reference: resource.reference,
+      title: resource.title,
+      source: "user",
+      addedBy: ctx.id,
+      addedAt: now
+    }));
+    return {
+      id: newIntakeId(),
+      projectId: input.projectId,
+      title,
+      originalRequest: input.originalRequest,
+      normalizedSummary: deterministicSummary(input.originalRequest),
+      requestType,
+      status: "draft",
+      priority: input.priority ?? "unspecified",
+      requestedBy: input.requestedBy,
+      ...input.businessGoal !== void 0 ? { businessGoal: input.businessGoal } : {},
+      targetUsers: [...input.targetUsers ?? []],
+      ...input.expectedOutcome !== void 0 ? { expectedOutcome: input.expectedOutcome } : {},
+      ...input.scopeNotes !== void 0 ? { scopeNotes: input.scopeNotes } : {},
+      constraints: [...input.constraints ?? []],
+      providedContext: [...input.providedContext ?? []],
+      attachments,
+      relatedResources,
+      answers: [],
+      questions: buildInitialQuestions(input, this.catalog),
+      llmSuggestions: [],
+      metadata: { ...input.metadata ?? {} },
+      fieldSources: {
+        ...titleProvided ? { title: "user" } : { title: "deterministic" },
+        normalized_summary: "deterministic",
+        request_type: input.requestType !== void 0 ? "user" : "deterministic",
+        priority: input.priority !== void 0 ? "user" : "deterministic",
+        ...input.businessGoal !== void 0 ? { business_goal: "user" } : {},
+        ...input.targetUsers !== void 0 ? { target_users: "user" } : {},
+        ...input.expectedOutcome !== void 0 ? { expected_outcome: "user" } : {},
+        ...input.scopeNotes !== void 0 ? { scope_notes: "user" } : {},
+        ...input.constraints !== void 0 ? { constraints: "user" } : {},
+        ...input.providedContext !== void 0 ? { provided_context: "user" } : {},
+        ...attachments.length > 0 ? { attachments: "user" } : {},
+        ...relatedResources.length > 0 ? { related_resources: "user" } : {}
+      },
+      ...idempotencyKey !== void 0 && idempotencyKey.length > 0 ? { idempotencyKey } : {},
+      version: 1,
+      history: [{ at: now, actor: ctx.id, actorType: ctx.type, action: "created" }],
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  async requireRecord(id, ctx, operation) {
+    const record = await this.store.load(id);
+    if (!record) throw new IntakeNotFoundError(id);
+    await this.authorize(operation, ctx, record);
+    return record;
+  }
+  async authorize(operation, ctx, record) {
+    const allowed = await this.authorizer.isAllowed(operation, ctx, record);
+    if (!allowed) {
+      this.metrics.increment("intake.unauthorized_attempt");
+      throw new IntakeAuthorizationError(operation, ctx.id, ctx.projectId);
+    }
+  }
+  assertMutable(record, action) {
+    if (!isMutableStatus(record.status)) {
+      throw new IntakeStatusLockedError(record.id, record.status, action);
+    }
+  }
+  assertAnswerField(field) {
+    const catalogFields = new Set(this.catalog.map((template) => template.field));
+    if (!catalogFields.has(field) && !INTAKE_FIELDS.includes(field)) {
+      throw new IntakeValidationError([
+        { field: "field", message: `unknown intake field: ${field}` }
+      ]);
+    }
+  }
+  assertSubmitReady(record) {
+    const issues = [];
+    if (record.originalRequest.trim().length === 0) {
+      issues.push({ field: "originalRequest", message: "original request must not be empty" });
+    }
+    if (record.title.trim().length === 0) {
+      issues.push({ field: "title", message: "title must not be empty" });
+    }
+    if (record.requestedBy.trim().length === 0) {
+      issues.push({ field: "requestedBy", message: "requester must not be empty" });
+    }
+    if (record.projectId.trim().length === 0) {
+      issues.push({ field: "projectId", message: "project must not be empty" });
+    }
+    if (issues.length > 0) {
+      this.metrics.increment("intake.validation_failure");
+      throw new IntakeValidationError(issues, "Requirement intake is not ready for submission");
+    }
+  }
+  findSuggestion(record, proposalId) {
+    const proposal2 = record.llmSuggestions.find((candidate) => candidate.id === proposalId);
+    if (!proposal2) {
+      throw new IntakeValidationError([
+        { field: "suggestionId", message: `suggestion not found: ${proposalId}` }
+      ]);
+    }
+    return proposal2;
+  }
+  applyProposal(record, proposal2) {
+    switch (proposal2.kind) {
+      case "title": {
+        const value = assertSuggestionString(proposal2.value, "title", MAX_TITLE_LENGTH);
+        record.title = value;
+        record.fieldSources.title = "llm";
+        break;
+      }
+      case "summary": {
+        const value = assertSuggestionString(
+          proposal2.value,
+          "normalized_summary",
+          MAX_SUMMARY_LENGTH
+        );
+        record.normalizedSummary = value;
+        record.fieldSources.normalized_summary = "llm";
+        break;
+      }
+      case "request_type": {
+        const value = normalizeRequestType(proposal2.value);
+        record.requestType = value;
+        record.fieldSources.request_type = "llm";
+        break;
+      }
+      case "priority": {
+        const value = String(proposal2.value).trim().toLowerCase();
+        if (INTAKE_PRIORITIES.includes(value)) {
+          record.priority = value;
+          record.fieldSources.priority = "llm";
+        }
+        break;
+      }
+      case "constraint": {
+        const value = assertSuggestionString(proposal2.value, "constraint", MAX_STRING_FIELD_LENGTH);
+        appendItems(record.constraints, value);
+        record.fieldSources.constraints = "llm";
+        break;
+      }
+      case "target_user": {
+        const value = assertSuggestionString(
+          proposal2.value,
+          "target_user",
+          MAX_STRING_FIELD_LENGTH
+        );
+        appendItems(record.targetUsers, value);
+        record.fieldSources.target_users = "llm";
+        break;
+      }
+      case "outcome": {
+        const value = assertSuggestionString(proposal2.value, "outcome", MAX_STRING_FIELD_LENGTH);
+        record.expectedOutcome = value;
+        record.fieldSources.expected_outcome = "llm";
+        break;
+      }
+      case "question": {
+        const template = proposal2.value;
+        if (typeof template === "object" && template !== null && typeof template.field === "string" && typeof template.question === "string") {
+          upsertQuestion(record, {
+            field: template.field,
+            question: template.question,
+            required: template.required
+          });
+        }
+        break;
+      }
+    }
+  }
+  updateMeta(ctx, action, fields, expectedVersion) {
+    return {
+      actorId: ctx.id,
+      actorType: ctx.type,
+      action,
+      fields,
+      ...expectedVersion !== void 0 ? { expectedVersion } : {}
+    };
+  }
+  afterMutation(record, ctx, event) {
+    this.logger.info("intake", "intake.updated", {
+      intakeId: record.id,
+      projectId: record.projectId,
+      actorId: ctx.id
+    });
+    this.emit(event, {
+      intakeId: record.id,
+      projectId: record.projectId,
+      actorId: ctx.id,
+      actorType: ctx.type,
+      status: record.status
+    });
+  }
+  emit(event, data) {
+    this.emitter.emit(event, data);
+  }
+  guardValidation(fn) {
+    try {
+      return fn();
+    } catch (error) {
+      if (error instanceof IntakeValidationError) {
+        this.metrics.increment("intake.validation_failure");
+      }
+      throw error;
+    }
+  }
+};
+function applyOptionalString(record, field, value) {
+  if (value === void 0) return;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    delete record[field];
+  } else {
+    record[field] = trimmed;
+  }
+}
+function markUserSources(record, changedKeys) {
+  const mapping = {
+    title: "title",
+    requestType: "request_type",
+    priority: "priority",
+    businessGoal: "business_goal",
+    targetUsers: "target_users",
+    expectedOutcome: "expected_outcome",
+    scopeNotes: "scope_notes",
+    constraints: "constraints",
+    providedContext: "provided_context"
+  };
+  for (const key of changedKeys) {
+    const sourceField = mapping[key];
+    if (sourceField) {
+      record.fieldSources[sourceField] = "user";
+    }
+  }
+}
+function markQuestionAnswered(record, field, value) {
+  const question = record.questions.find((candidate) => candidate.field === field);
+  if (question && question.status === "unanswered") {
+    question.status = "answered";
+    question.answer = value;
+  }
+}
+export {
+  ALLOWED_TRANSITIONS,
+  AllowAllIntakeAuthorizer,
+  DEFAULT_INTAKE_QUESTIONS,
+  DenyAllIntakeAuthorizer,
+  INTAKE_ATTACHMENT_KINDS,
+  INTAKE_COUNTERS,
+  INTAKE_EVENT_NAMES,
+  INTAKE_FIELDS,
+  INTAKE_FIELD_SOURCES,
+  INTAKE_ID_PREFIX,
+  INTAKE_OPERATIONS,
+  INTAKE_PRIORITIES,
+  INTAKE_QUESTION_STATUSES,
+  INTAKE_STATUSES,
+  INTAKE_TIMERS,
+  InMemoryIntakeLogger,
+  InMemoryIntakeMetrics,
+  IntakeAuthorizationError,
+  IntakeConflictError,
+  IntakeError,
+  IntakeEventEmitter,
+  IntakeNotFoundError,
+  IntakeStateTransitionError,
+  IntakeStatusLockedError,
+  IntakeSuggestionError,
+  IntakeValidationError,
+  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,
+  MUTABLE_STATUSES,
+  NoopIntakeLogger,
+  NoopIntakeMetrics,
+  ProjectMembershipIntakeAuthorizer,
+  RELATED_RESOURCE_KINDS,
+  REQUEST_TYPES,
+  RequirementIntakeService,
+  RequirementIntakeStore,
+  SUGGESTION_KINDS,
+  SUGGESTION_STATUSES,
+  answerInputSchema,
+  assertSuggestionString,
+  assertTransition,
+  attachResourceInputSchema,
+  attachmentInputSchema,
+  buildInitialQuestions,
+  canTransition,
+  createIntakeSchema,
+  deterministicSummary,
+  deterministicTitle,
+  isBlank,
+  isKnownStatus,
+  isMutableStatus,
+  isTerminalStatus,
+  llmSuggestionOutputSchema,
+  metadataSchema,
+  newIntakeId,
+  normalizeRequestType,
+  parseWithIssues,
+  pendingQuestions,
+  prioritySchema,
+  questionTemplateInputSchema,
+  relatedResourceInputSchema,
+  requestTypeSchema,
+  toProposals,
+  updateIntakeSchema,
+  upsertQuestion,
+  validateAnswerInput,
+  validateAttachResourceInput,
+  validateAttachmentInput,
+  validateCreateInput,
+  validateFieldSource,
+  validateLlmSuggestionOutput,
+  validateQuestionTemplateInput,
+  validateRelatedResourceInput,
+  validateUpdateInput
+};
+//# sourceMappingURL=index.js.map