@wrongstack/requirement-intake 1.0.29 → 1.0.32

package/dist/index.js

@@ -28,14 +28,14 @@ var ProjectMembershipIntakeAuthorizer = class {
   ownerOnly;
   constructor(options) {
     this.projectsOf = options.projectsOf;
-    this.ownerOnly = options.ownerOnlyOperations ?? /* @__PURE__ */ new Set();
+    this.ownerOnly = new Set(options.ownerOnlyOperations);
   }
   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;
+    if (this.ownerOnly.has(operation)) {
+      return record !== void 0 && record.requestedBy === ctx.id;
     }
     return true;
   }
@@ -215,7 +215,11 @@ 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 };
+    const payload = Object.freeze({
+      ...data,
+      event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
     for (const listener of [...this.listeners]) {
       try {
         listener(payload);
@@ -253,6 +257,7 @@ var ALLOWED_TRANSITIONS = {
 };
 var MUTABLE_STATUSES = ["draft", "collecting_information"];
 function canTransition(from, to) {
+  if (!Object.hasOwn(ALLOWED_TRANSITIONS, from)) return false;
   return ALLOWED_TRANSITIONS[from]?.includes(to) ?? false;
 }
 function assertTransition(from, to) {
@@ -271,6 +276,9 @@ function isKnownStatus(value) {
 }
 
 // src/logger.ts
+function snapshotFields(fields) {
+  return fields === void 0 ? void 0 : { ...fields };
+}
 var NoopIntakeLogger = class {
   info(_scope, _message, _fields) {
   }
@@ -286,7 +294,7 @@ var InMemoryIntakeLogger = class {
       level: "info",
       scope,
       message,
-      ...fields !== void 0 ? { fields } : {}
+      ...fields !== void 0 ? { fields: snapshotFields(fields) } : {}
     });
   }
   warn(scope, message, fields) {
@@ -294,7 +302,7 @@ var InMemoryIntakeLogger = class {
       level: "warn",
       scope,
       message,
-      ...fields !== void 0 ? { fields } : {}
+      ...fields !== void 0 ? { fields: snapshotFields(fields) } : {}
     });
   }
   error(scope, message, fields) {
@@ -302,7 +310,7 @@ var InMemoryIntakeLogger = class {
       level: "error",
       scope,
       message,
-      ...fields !== void 0 ? { fields } : {}
+      ...fields !== void 0 ? { fields: snapshotFields(fields) } : {}
     });
   }
 };
@@ -377,7 +385,7 @@ function makeQuestion(template, order, skipped) {
 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 answeredByInput = Object.hasOwn(FIELD_TO_INPUT_PROPERTY, template.field) ? FIELD_TO_INPUT_PROPERTY[template.field]?.(input) ?? false : false;
     const skipped = answeredByInput || known.has(template.field);
     return makeQuestion(template, index, skipped);
   });
@@ -411,6 +419,11 @@ var IDEMPOTENCY_PATH = "_idempotency.json";
 function hashIdempotencyKey(key) {
   return createHash("sha256").update(key, "utf8").digest("hex");
 }
+function positiveIntegerOrDefault(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  const normalized = Math.floor(value);
+  return Number.isSafeInteger(normalized) && normalized >= 1 ? normalized : fallback;
+}
 function indexEntryFor(record) {
   return {
     id: record.id,
@@ -434,7 +447,7 @@ var RequirementIntakeStore = class {
     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.maxIdempotencyEntries = positiveIntegerOrDefault(options.maxIdempotencyEntries, 1e4);
     this.lockTimeoutMs = options.lockTimeoutMs ?? 15e3;
   }
   get directory() {
@@ -544,6 +557,7 @@ var RequirementIntakeStore = class {
         }
         const next = structuredClone(current);
         await mutate(next);
+        next.id = current.id;
         next.version = current.version + 1;
         next.updatedAt = Date.now();
         this.appendHistory(next, options);
@@ -617,20 +631,73 @@ var RequirementIntakeStore = class {
         } else {
           index.entries.push(entry);
         }
-        await atomicWrite(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
+        try {
+          await atomicWrite(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
+        } catch (error) {
+          try {
+            await fsp.unlink(this.indexPath);
+          } catch {
+          }
+          throw error;
+        }
       },
       { timeoutMs: this.lockTimeoutMs }
     );
   }
   async readIdempotency() {
+    let raw;
     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 {
+      raw = await fsp.readFile(this.idempotencyPath, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return { version: 1, entries: {} };
+      throw error;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      if (error instanceof SyntaxError) return this.recoverIdempotency();
+      throw error;
+    }
+    if (parsed?.version !== 1 || !parsed.entries || typeof parsed.entries !== "object" || Array.isArray(parsed.entries)) {
+      return this.recoverIdempotency();
+    }
+    return parsed;
+  }
+  /** Rebuild a lost/corrupt idempotency index from its durable record files. */
+  async recoverIdempotency() {
+    let files;
+    try {
+      files = await fsp.readdir(this.baseDir);
+    } catch (error) {
+      if (error.code === "ENOENT") return { version: 1, entries: {} };
+      throw error;
+    }
+    const entries = {};
+    for (const file of files) {
+      if (file === INDEX_PATH || file === IDEMPOTENCY_PATH || !file.endsWith(".json")) continue;
+      const id = file.slice(0, -".json".length);
+      if (!/^[A-Za-z0-9_-]{1,128}$/.test(id)) continue;
+      let record;
+      try {
+        record = JSON.parse(
+          await fsp.readFile(path.join(this.baseDir, file), "utf8")
+        );
+      } catch (error) {
+        if (error.code === "ENOENT") continue;
+        throw error;
+      }
+      if (record?.id !== id) throw new Error(`Invalid requirement intake record: ${file}`);
+      const key = record.idempotencyKey;
+      if (typeof key !== "string" || key.trim().length === 0) continue;
+      const digest = hashIdempotencyKey(key.trim());
+      if (!Object.hasOwn(entries, digest)) {
+        entries[digest] = { intakeId: record.id, createdAt: record.createdAt };
+      }
     }
-    return { version: 1, entries: {} };
+    const recovered = { version: 1, entries };
+    await this.pruneIdempotency(recovered);
+    return recovered;
   }
   async pruneIdempotency(map) {
     const entries = Object.entries(map.entries);
@@ -658,7 +725,7 @@ 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) => {
+var httpUrlSchema = z.string().trim().max(MAX_REFERENCE_LENGTH).refine((value) => {
   try {
     const url = new URL(value);
     return url.protocol === "http:" || url.protocol === "https:";
@@ -666,26 +733,30 @@ var httpUrlSchema = z.string().max(MAX_REFERENCE_LENGTH).refine((value) => {
     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 idSchema = z.string().trim().min(1).max(128);
 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 normalizedOptionalString = (max) => z.string().trim().max(max).transform((value) => value.length > 0 ? value : void 0).optional();
 var attachmentInputSchema = z.object({
-  name: nonBlankString(200, "attachment name"),
+  name: z.string().trim().min(1).max(200),
   kind: z.enum(INTAKE_ATTACHMENT_KINDS),
-  path: z.string().max(MAX_REFERENCE_LENGTH).optional(),
+  path: z.string().trim().min(1).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()
+  mimeType: normalizedOptionalString(100)
 }).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()
+  reference: z.string().trim().min(1).max(MAX_REFERENCE_LENGTH),
+  title: normalizedOptionalString(200)
+}).refine((value) => value.kind !== "url" || httpUrlSchema.safeParse(value.reference).success, {
+  path: ["reference"],
+  message: "URL resource reference must be a valid http(s) URL"
 });
 var questionTemplateInputSchema = z.object({
-  field: nonBlankString(64, "question field"),
-  question: nonBlankString(MAX_QUESTION_LENGTH, "question text"),
+  field: z.string().trim().min(1).max(64),
+  question: z.string().trim().min(1).max(MAX_QUESTION_LENGTH),
   required: z.boolean().optional()
 });
 var metadataSchema = z.record(z.string().max(64), z.unknown()).superRefine((value, ctx) => {
@@ -762,12 +833,9 @@ var updateIntakeSchema = z.object({
   vibeProtocol: vibeProtocolStateSchema.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()
+  field: z.string().trim().min(1, "answer field must not be empty or whitespace-only").max(64, "answer field exceeds the maximum length of 64 characters"),
+  answer: z.string().trim().min(1).max(MAX_ANSWER_LENGTH),
+  question: z.string().trim().max(MAX_QUESTION_LENGTH).transform((value) => value.length > 0 ? value : void 0).optional()
 });
 var attachResourceInputSchema = z.object({
   attachment: attachmentInputSchema.optional(),
@@ -825,16 +893,20 @@ function validateFieldSource(value) {
   throw new IntakeValidationError([{ field: "source", message: "invalid field source" }]);
 }
 function deterministicSummary(originalRequest, maxLength = 240) {
+  const limit = Number.isFinite(maxLength) ? Math.max(0, Math.floor(maxLength)) : 0;
+  if (limit === 0) return "";
   const collapsed = originalRequest.replace(/\s+/g, " ").trim();
-  if (collapsed.length <= maxLength) return collapsed;
-  return `${collapsed.slice(0, Math.max(0, maxLength - 1)).trimEnd()}\u2026`;
+  if (collapsed.length <= limit) return collapsed;
+  return `${collapsed.slice(0, limit - 1).trimEnd()}\u2026`;
 }
 function deterministicTitle(originalRequest, maxLength = MAX_TITLE_LENGTH) {
+  const limit = Number.isFinite(maxLength) ? Math.max(0, Math.floor(maxLength)) : 0;
+  if (limit === 0) return "";
   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`;
+  const title = firstLine.length === 0 ? "Untitled request" : firstLine;
+  if (title.length <= limit) return title;
+  return `${title.slice(0, limit - 1).trimEnd()}\u2026`;
 }
 
 // src/suggestions.ts
@@ -913,12 +985,13 @@ function toProposals(suggestion) {
   return proposals;
 }
 function assertSuggestionString(value, label, max) {
-  if (typeof value !== "string" || value.trim().length === 0 || value.length > max) {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  if (trimmed.length === 0 || trimmed.length > max) {
     throw new IntakeValidationError([
       { field: `suggestion.${label}`, message: `invalid ${label} suggestion value` }
     ]);
   }
-  return value;
+  return trimmed;
 }
 
 // src/vibe.ts
@@ -928,14 +1001,19 @@ function hasVibeTag(text) {
   return VIBE_TAG_REGEX.test(text);
 }
 function stripVibeTag(text) {
-  return text.replace(/\[VIBE\]/gi, "").replace(/[ \t]{2,}/g, " ").trim();
+  return text.replace(/(?:\[VIBE\])+/gi, (tags, offset, source) => {
+    const before = source[offset - 1];
+    const after = source[offset + tags.length];
+    return before !== void 0 && after !== void 0 && /[\p{L}\p{N}_]/u.test(before) && /[\p{L}\p{N}_]/u.test(after) ? " " : "";
+  }).replace(/[ \t]{2,}/g, " ").trim();
 }
 function deriveVibeState(rawText, existingState, now = Date.now()) {
   const containsTag = hasVibeTag(rawText);
   if (existingState?.isVibeMode) {
     return {
       ...existingState,
-      isVibeMode: true
+      isVibeMode: true,
+      ...existingState.auditNotes !== void 0 ? { auditNotes: [...existingState.auditNotes] } : {}
     };
   }
   if (containsTag) {
@@ -1013,6 +1091,9 @@ function buildNewIntakeRecord(input, ctx, now, catalog) {
   const title = titleProvided ? input.title.trim() : deterministicTitle(input.originalRequest);
   const requestType = normalizeRequestType(input.requestType);
   const idempotencyKey = input.idempotencyKey?.trim();
+  const businessGoal = input.businessGoal?.trim();
+  const expectedOutcome = input.expectedOutcome?.trim();
+  const scopeNotes = input.scopeNotes?.trim();
   const attachments = (input.attachments ?? []).map((attachment) => ({
     id: `${ATTACHMENT_ID_PREFIX}${ulid4()}`,
     name: attachment.name,
@@ -1050,10 +1131,10 @@ function buildNewIntakeRecord(input, ctx, now, catalog) {
     priority: input.priority ?? "unspecified",
     requestedBy: input.requestedBy,
     ...vibeState ? { isVibeMode: true, vibeProtocol: vibeState } : {},
-    ...input.businessGoal !== void 0 ? { businessGoal: input.businessGoal } : {},
+    ...businessGoal ? { businessGoal } : {},
     targetUsers: [...input.targetUsers ?? []],
-    ...input.expectedOutcome !== void 0 ? { expectedOutcome: input.expectedOutcome } : {},
-    ...input.scopeNotes !== void 0 ? { scopeNotes: input.scopeNotes } : {},
+    ...expectedOutcome ? { expectedOutcome } : {},
+    ...scopeNotes ? { scopeNotes } : {},
     constraints: [...input.constraints ?? []],
     providedContext: [...input.providedContext ?? []],
     attachments,
@@ -1067,10 +1148,10 @@ function buildNewIntakeRecord(input, ctx, now, catalog) {
       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" } : {},
+      ...businessGoal ? { business_goal: "user" } : {},
       ...input.targetUsers !== void 0 ? { target_users: "user" } : {},
-      ...input.expectedOutcome !== void 0 ? { expected_outcome: "user" } : {},
-      ...input.scopeNotes !== void 0 ? { scope_notes: "user" } : {},
+      ...expectedOutcome ? { expected_outcome: "user" } : {},
+      ...scopeNotes ? { scope_notes: "user" } : {},
       ...input.constraints !== void 0 ? { constraints: "user" } : {},
       ...input.providedContext !== void 0 ? { provided_context: "user" } : {},
       ...attachments.length > 0 ? { attachments: "user" } : {},
@@ -1327,13 +1408,14 @@ var RequirementIntakeService = class {
   async createIntake(input, ctx) {
     const validated = this.guardValidation(() => validateCreateInput(input));
     if (validated.projectId !== ctx.projectId) {
-      throw new IntakeAuthorizationError("create", ctx.id, validated.projectId);
+      this.denyUnauthorized("create", ctx, 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) {
+          this.recordUnauthorizedAttempt();
           throw new IntakeValidationError([
             {
               field: "idempotencyKey",
@@ -1355,6 +1437,7 @@ var RequirementIntakeService = class {
     const result = await this.store.create(record, validated.idempotencyKey?.trim());
     if (!result.created) {
       if (result.record.projectId !== ctx.projectId) {
+        this.recordUnauthorizedAttempt();
         throw new IntakeValidationError([
           {
             field: "idempotencyKey",
@@ -1396,7 +1479,7 @@ var RequirementIntakeService = class {
   }
   async listIntakes(projectId, ctx, filter) {
     if (projectId !== ctx.projectId) {
-      throw new IntakeAuthorizationError("list", ctx.id, projectId);
+      this.denyUnauthorized("list", ctx, projectId);
     }
     await this.authorize("list", ctx);
     return this.store.list(projectId, filter);
@@ -1451,7 +1534,7 @@ var RequirementIntakeService = class {
     const record = await this.requireRecord(id, ctx, "answer");
     this.assertMutable(record, "addAnswer");
     const validated = this.guardValidation(() => validateAnswerInput(input));
-    this.assertAnswerField(validated.field);
+    this.assertAnswerField(record, validated.field);
     return this.store.update(
       id,
       this.updateMeta(ctx, "answer_added", [validated.field], expectedVersion),
@@ -1547,30 +1630,27 @@ var RequirementIntakeService = class {
       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) => {
-        this.assertMutable(next, "generateSuggestions");
-        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;
-        }
+    let previousStatus = record.status;
+    const updateOptions = {
+      actorId: ctx.id,
+      actorType: ctx.type,
+      action: hadQuestions ? "information_requested" : "suggestions_added"
+    };
+    const updated = await this.store.update(id, updateOptions, (next) => {
+      this.assertMutable(next, "generateSuggestions");
+      previousStatus = next.status;
+      if (next.status === "draft") {
+        updateOptions.from = "draft";
+        updateOptions.to = "collecting_information";
+        next.status = "collecting_information";
       }
-    );
+      next.llmSuggestions.push(...proposals);
+      if (next.llmSuggestions.length > MAX_SUGGESTIONS) {
+        next.llmSuggestions = next.llmSuggestions.slice(
+          next.llmSuggestions.length - MAX_SUGGESTIONS
+        );
+      }
+    });
     this.metrics.increment("intake.suggestions.succeeded");
     this.logger.info("intake", "intake.suggestions.succeeded", {
       intakeId: updated.id,
@@ -1657,24 +1737,25 @@ var RequirementIntakeService = class {
     assertTransition(record.status, "submitted");
     this.assertSubmitReady(record);
     const now = Date.now();
+    let previousStatus = record.status;
+    const updateOptions = {
+      actorId: ctx.id,
+      actorType: ctx.type,
+      action: "submitted",
+      expectedVersion: expectedVersion ?? record.version
+    };
     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;
-        }
-      );
+      const updated = await this.store.update(id, updateOptions, (next) => {
+        assertTransition(next.status, "submitted");
+        this.assertSubmitReady(next);
+        previousStatus = next.status;
+        updateOptions.from = next.status;
+        updateOptions.to = "submitted";
+        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", {
@@ -1687,7 +1768,7 @@ var RequirementIntakeService = class {
         projectId: updated.projectId,
         actorId: ctx.id,
         actorType: ctx.type,
-        previousStatus: record.status,
+        previousStatus,
         status: "submitted"
       });
       return { record: updated, idempotent: false };
@@ -1775,7 +1856,11 @@ var RequirementIntakeService = class {
   // Internals
   // -------------------------------------------------------------------------
   buildNewRecord(input, ctx, now) {
-    return buildNewIntakeRecord(input, ctx, now, this.catalog);
+    const catalog = input.questions?.map((question) => ({
+      ...question,
+      required: question.required ?? false
+    }));
+    return buildNewIntakeRecord(input, ctx, now, catalog ?? this.catalog);
   }
   async requireRecord(id, ctx, operation) {
     const record = await this.store.load(id);
@@ -1786,18 +1871,25 @@ var RequirementIntakeService = class {
   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);
+      this.denyUnauthorized(operation, ctx, ctx.projectId);
     }
   }
+  denyUnauthorized(operation, ctx, projectId) {
+    this.recordUnauthorizedAttempt();
+    throw new IntakeAuthorizationError(operation, ctx.id, projectId);
+  }
+  recordUnauthorizedAttempt() {
+    this.metrics.increment("intake.unauthorized_attempt");
+  }
   assertMutable(record, action) {
     if (!isMutableStatus(record.status)) {
       throw new IntakeStatusLockedError(record.id, record.status, action);
     }
   }
-  assertAnswerField(field) {
+  assertAnswerField(record, field) {
     const catalogFields = new Set(this.catalog.map((template) => template.field));
-    if (!catalogFields.has(field) && !INTAKE_FIELDS.includes(field)) {
+    const recordHasField = record.questions.some((question) => question.field === field);
+    if (!recordHasField && !catalogFields.has(field) && !INTAKE_FIELDS.includes(field)) {
       throw new IntakeValidationError([
         { field: "field", message: `unknown intake field: ${field}` }
       ]);

package/dist/service.d.ts

@@ -74,6 +74,8 @@ export declare class RequirementIntakeService {
     private buildNewRecord;
     private requireRecord;
     private authorize;
+    private denyUnauthorized;
+    private recordUnauthorizedAttempt;
     private assertMutable;
     private assertAnswerField;
     private assertSubmitReady;

package/dist/store.d.ts

@@ -74,6 +74,8 @@ export declare class RequirementIntakeStore {
     private readIndex;
     private updateIndexFor;
     private readIdempotency;
+    /** Rebuild a lost/corrupt idempotency index from its durable record files. */
+    private recoverIdempotency;
     private pruneIdempotency;
 }
 /** Generate a store-compatible record id (`reqi_<ulid>`). */

package/dist/validation.d.ts

@@ -55,7 +55,7 @@ export declare const attachmentInputSchema: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
     url: z.ZodOptional<z.ZodString>;
     sizeBytes: z.ZodOptional<z.ZodNumber>;
-    mimeType: z.ZodOptional<z.ZodString>;
+    mimeType: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>;
 }, z.core.$strip>;
 export declare const relatedResourceInputSchema: z.ZodObject<{
     kind: z.ZodEnum<{
@@ -67,7 +67,7 @@ export declare const relatedResourceInputSchema: z.ZodObject<{
         url: "url";
     }>;
     reference: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>;
 }, z.core.$strip>;
 export declare const questionTemplateInputSchema: z.ZodObject<{
     field: z.ZodString;
@@ -124,7 +124,7 @@ export declare const createIntakeSchema: z.ZodObject<{
         path: z.ZodOptional<z.ZodString>;
         url: z.ZodOptional<z.ZodString>;
         sizeBytes: z.ZodOptional<z.ZodNumber>;
-        mimeType: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>;
     }, z.core.$strip>>>;
     relatedResources: z.ZodOptional<z.ZodArray<z.ZodObject<{
         kind: z.ZodEnum<{
@@ -136,7 +136,7 @@ export declare const createIntakeSchema: z.ZodObject<{
             url: "url";
         }>;
         reference: z.ZodString;
-        title: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>;
     }, z.core.$strip>>>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     idempotencyKey: z.ZodOptional<z.ZodString>;
@@ -204,7 +204,7 @@ export declare const updateIntakeSchema: z.ZodObject<{
 export declare const answerInputSchema: z.ZodObject<{
     field: z.ZodString;
     answer: z.ZodString;
-    question: z.ZodOptional<z.ZodString>;
+    question: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>;
 }, z.core.$strip>;
 export declare const attachResourceInputSchema: z.ZodObject<{
     attachment: z.ZodOptional<z.ZodObject<{
@@ -219,7 +219,7 @@ export declare const attachResourceInputSchema: z.ZodObject<{
         path: z.ZodOptional<z.ZodString>;
         url: z.ZodOptional<z.ZodString>;
         sizeBytes: z.ZodOptional<z.ZodNumber>;
-        mimeType: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>;
     }, z.core.$strip>>;
     relatedResource: z.ZodOptional<z.ZodObject<{
         kind: z.ZodEnum<{
@@ -231,7 +231,7 @@ export declare const attachResourceInputSchema: z.ZodObject<{
             url: "url";
         }>;
         reference: z.ZodString;
-        title: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/requirement-intake",
-  "version": "1.0.29",
+  "version": "1.0.32",
   "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.29",
+    "@wrongstack/core": "1.0.32",
     "zod": "4.6.2"
   },
   "devDependencies": {