@wrongstack/requirement-intake 1.0.19 → 1.0.26

package/dist/index.d.ts

@@ -17,6 +17,6 @@ export { type IntakeCreateResult, type IntakeListFilter, type IntakeSubmitResult
 export { type IntakeIndexEntry, newIntakeId, RequirementIntakeStore, type RequirementIntakeStoreOptions, type StoreCreateResult, type StoreUpdateOptions, } from './store.js';
 export { assertSuggestionString, type LlmSuggestionGenerator, type LlmSuggestionOutput, type LlmSuggestionRequest, llmSuggestionOutputSchema, type NormalizedLlmSuggestion, toProposals, validateLlmSuggestionOutput, } from './suggestions.js';
 export { type AddAnswerInput, type AttachResourceInput, type ChangeHistoryEntry, type CreateIntakeInput, INTAKE_EVENT_NAMES, type IntakeActor, type IntakeAnswer, type IntakeAttachment, type IntakeAttachmentInput, type IntakeContext, type IntakeEvent, type IntakeEventName, type IntakeQuestion, type IntakeQuestionTemplateInput, type LlmSuggestionProposal, type RelatedResource, type RelatedResourceInput, type RequirementIntakeRecord, type UpdateIntakeInput, } from './types.js';
-export { answerInputSchema, attachmentInputSchema, attachResourceInputSchema, createIntakeSchema, deterministicSummary, deterministicTitle, isBlank, metadataSchema, normalizeRequestType, parseWithIssues, prioritySchema, questionTemplateInputSchema, relatedResourceInputSchema, requestTypeSchema, updateIntakeSchema, validateAnswerInput, validateAttachmentInput, validateAttachResourceInput, validateCreateInput, validateFieldSource, validateQuestionTemplateInput, validateRelatedResourceInput, validateUpdateInput, } from './validation.js';
+export { answerInputSchema, attachmentInputSchema, attachResourceInputSchema, createIntakeSchema, deterministicSummary, deterministicTitle, isBlank, metadataSchema, normalizeRequestType, parseWithIssues, prioritySchema, questionTemplateInputSchema, relatedResourceInputSchema, requestTypeSchema, updateIntakeSchema, validateAnswerInput, validateAttachmentInput, validateAttachResourceInput, validateCreateInput, validateFieldSource, validateQuestionTemplateInput, validateRelatedResourceInput, validateUpdateInput, vibeProtocolStateSchema, } from './validation.js';
 export { deriveVibeState, hasVibeTag, stripVibeTag, VIBE_TAG_REGEX, type VibeProtocolStage, type VibeProtocolState, } from './vibe.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -413,6 +413,19 @@ var IDEMPOTENCY_PATH = "_idempotency.json";
 function hashIdempotencyKey(key) {
   return createHash("sha256").update(key, "utf8").digest("hex");
 }
+function indexEntryFor(record) {
+  return {
+    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
+  };
+}
 var RequirementIntakeStore = class {
   baseDir;
   indexPath;
@@ -430,6 +443,14 @@ var RequirementIntakeStore = class {
     return this.baseDir;
   }
   recordPath(id) {
+    if (!/^[A-Za-z0-9_-]{1,128}$/.test(id)) {
+      throw new IntakeValidationError([
+        {
+          field: "id",
+          message: "record id must contain only letters, numbers, underscores, or hyphens"
+        }
+      ]);
+    }
     return path.join(this.baseDir, `${id}.json`);
   }
   // -------------------------------------------------------------------------
@@ -558,26 +579,37 @@ var RequirementIntakeStore = class {
       const raw = await fsp.readFile(this.indexPath, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed?.version === 1 && Array.isArray(parsed.entries)) return parsed;
-    } catch {
+    } catch (error) {
+      if (error.code !== "ENOENT" && !(error instanceof SyntaxError)) {
+        throw error;
+      }
+    }
+    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;
+      const record = JSON.parse(
+        await fsp.readFile(path.join(this.baseDir, file), "utf8")
+      );
+      if (record?.id !== id) throw new Error(`Invalid requirement intake record: ${file}`);
+      entries.push(indexEntryFor(record));
     }
-    return { version: 1, entries: [] };
+    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 entry = indexEntryFor(record);
         const position = index.entries.findIndex((candidate) => candidate.id === record.id);
         if (position >= 0) {
           index.entries[position] = entry;
@@ -683,6 +715,15 @@ 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 vibeProtocolStateSchema = z.object({
+  isVibeMode: z.literal(true),
+  detectedAt: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  stage: z.enum(["synthesizer", "coder", "auditor", "passed"]),
+  synthesizedSpec: z.string().max(MAX_ANSWER_LENGTH).optional(),
+  coderContract: z.string().max(MAX_ANSWER_LENGTH).optional(),
+  auditVerdict: z.enum(["PASS", "REJECT"]).optional(),
+  auditNotes: z.array(z.string().max(MAX_STRING_FIELD_LENGTH)).max(MAX_ARRAY_ITEMS).optional()
+}).strict();
 var createIntakeSchema = z.object({
   projectId: idSchema,
   originalRequest: nonBlankString(MAX_REQUEST_LENGTH, "originalRequest"),
@@ -703,7 +744,7 @@ var createIntakeSchema = z.object({
   knownFields: z.array(z.string().trim().min(1).max(64)).max(MAX_ARRAY_ITEMS).optional(),
   questions: z.array(questionTemplateInputSchema).max(50).optional(),
   isVibeMode: z.boolean().optional(),
-  vibeProtocol: z.any().optional()
+  vibeProtocol: vibeProtocolStateSchema.optional()
 }).strict();
 var updateIntakeSchema = z.object({
   title: optionalString(MAX_TITLE_LENGTH),
@@ -717,7 +758,7 @@ var updateIntakeSchema = z.object({
   providedContext: optionalStringArray,
   metadata: metadataSchema.optional(),
   isVibeMode: z.boolean().optional(),
-  vibeProtocol: z.any().optional()
+  vibeProtocol: vibeProtocolStateSchema.optional()
 }).strict();
 var answerInputSchema = z.object({
   field: nonBlankString(64, "answer field"),
@@ -1203,6 +1244,12 @@ function applyAnswerUpdateToRecord(record, answerId, newAnswer) {
     question.answer = newAnswer;
     question.status = "answered";
   }
+  const mapping = ANSWER_FIELD_MAPPING[answer.field];
+  if (mapping) {
+    mapping.set(record, newAnswer);
+    const sourceKey = answer.field;
+    record.fieldSources[sourceKey] = "user";
+  }
 }
 function applyAttachmentToRecord(record, validated, actorId, now) {
   if (record.attachments.length >= MAX_ATTACHMENTS) {
@@ -1305,6 +1352,23 @@ var RequirementIntakeService = class {
     const now = Date.now();
     const record = this.buildNewRecord(validated, ctx, now);
     const result = await this.store.create(record, validated.idempotencyKey?.trim());
+    if (!result.created) {
+      if (result.record.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: result.record.id,
+        projectId: result.record.projectId,
+        actorId: ctx.id
+      });
+      return result;
+    }
     this.logger.info("intake", "intake.created", {
       intakeId: result.record.id,
       projectId: result.record.projectId,
@@ -1353,6 +1417,7 @@ var RequirementIntakeService = class {
       throw new IntakeValidationError([{ field: "title", message: "title must not be blank" }]);
     }
     return this.store.update(id, this.updateMeta(ctx, "updated", changedKeys, expectedVersion), (next) => {
+      this.assertMutable(next, "updateIntake");
       if (validated.title !== void 0) {
         next.title = validated.title.trim();
         next.fieldSources.title = "user";
@@ -1390,6 +1455,7 @@ var RequirementIntakeService = class {
       id,
       this.updateMeta(ctx, "answer_added", [validated.field], expectedVersion),
       (next) => {
+        this.assertMutable(next, "addAnswer");
         applyAnswerToRecord(next, validated, ctx.id, Date.now());
       }
     ).then((updated) => {
@@ -1407,6 +1473,7 @@ var RequirementIntakeService = class {
       })
     );
     return this.store.update(id, this.updateMeta(ctx, "answer_updated", [answerId], expectedVersion), (next) => {
+      this.assertMutable(next, "updateAnswer");
       applyAnswerUpdateToRecord(next, answerId, validated.answer);
     }).then((updated) => {
       this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
@@ -1423,6 +1490,7 @@ var RequirementIntakeService = class {
         id,
         this.updateMeta(ctx, "attachment_added", ["attachments"], expectedVersion),
         (next) => {
+          this.assertMutable(next, "attachResource");
           applyAttachmentToRecord(next, validated, ctx.id, now);
         }
       ).then((updated) => {
@@ -1434,6 +1502,7 @@ var RequirementIntakeService = class {
       id,
       this.updateMeta(ctx, "related_resource_added", ["related_resources"], expectedVersion),
       (next) => {
+        this.assertMutable(next, "attachResource");
         applyRelatedResourceToRecord(next, validated, ctx.id, now);
       }
     ).then((updated) => {
@@ -1489,6 +1558,7 @@ var RequirementIntakeService = class {
         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(
@@ -1530,6 +1600,7 @@ var RequirementIntakeService = class {
       id,
       this.updateMeta(ctx, "suggestion_accepted", [proposal2.kind], expectedVersion),
       (next) => {
+        this.assertMutable(next, "acceptSuggestion");
         const target = next.llmSuggestions.find((candidate) => candidate.id === proposalId);
         if (!target) {
           throw new IntakeValidationError([
@@ -1553,6 +1624,7 @@ var RequirementIntakeService = class {
       id,
       this.updateMeta(ctx, "suggestion_rejected", [proposalId], expectedVersion),
       (next) => {
+        this.assertMutable(next, "rejectSuggestion");
         const target = next.llmSuggestions.find((candidate) => candidate.id === proposalId);
         if (!target) {
           throw new IntakeValidationError([
@@ -1884,6 +1956,7 @@ export {
   validateLlmSuggestionOutput,
   validateQuestionTemplateInput,
   validateRelatedResourceInput,
-  validateUpdateInput
+  validateUpdateInput,
+  vibeProtocolStateSchema
 };
 //# sourceMappingURL=index.js.map

package/dist/validation.d.ts

@@ -75,6 +75,24 @@ export declare const questionTemplateInputSchema: z.ZodObject<{
     required: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const metadataSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+/** Strict, bounded representation of resumable VIBE protocol state. */
+export declare const vibeProtocolStateSchema: z.ZodObject<{
+    isVibeMode: z.ZodLiteral<true>;
+    detectedAt: z.ZodNumber;
+    stage: z.ZodEnum<{
+        auditor: "auditor";
+        coder: "coder";
+        passed: "passed";
+        synthesizer: "synthesizer";
+    }>;
+    synthesizedSpec: z.ZodOptional<z.ZodString>;
+    coderContract: z.ZodOptional<z.ZodString>;
+    auditVerdict: z.ZodOptional<z.ZodEnum<{
+        PASS: "PASS";
+        REJECT: "REJECT";
+    }>>;
+    auditNotes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
 export declare const createIntakeSchema: z.ZodObject<{
     projectId: z.ZodString;
     originalRequest: z.ZodString;
@@ -129,7 +147,23 @@ export declare const createIntakeSchema: z.ZodObject<{
         required: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
     isVibeMode: z.ZodOptional<z.ZodBoolean>;
-    vibeProtocol: z.ZodOptional<z.ZodAny>;
+    vibeProtocol: z.ZodOptional<z.ZodObject<{
+        isVibeMode: z.ZodLiteral<true>;
+        detectedAt: z.ZodNumber;
+        stage: z.ZodEnum<{
+            auditor: "auditor";
+            coder: "coder";
+            passed: "passed";
+            synthesizer: "synthesizer";
+        }>;
+        synthesizedSpec: z.ZodOptional<z.ZodString>;
+        coderContract: z.ZodOptional<z.ZodString>;
+        auditVerdict: z.ZodOptional<z.ZodEnum<{
+            PASS: "PASS";
+            REJECT: "REJECT";
+        }>>;
+        auditNotes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const updateIntakeSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
@@ -149,7 +183,23 @@ export declare const updateIntakeSchema: z.ZodObject<{
     providedContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     isVibeMode: z.ZodOptional<z.ZodBoolean>;
-    vibeProtocol: z.ZodOptional<z.ZodAny>;
+    vibeProtocol: z.ZodOptional<z.ZodObject<{
+        isVibeMode: z.ZodLiteral<true>;
+        detectedAt: z.ZodNumber;
+        stage: z.ZodEnum<{
+            auditor: "auditor";
+            coder: "coder";
+            passed: "passed";
+            synthesizer: "synthesizer";
+        }>;
+        synthesizedSpec: z.ZodOptional<z.ZodString>;
+        coderContract: z.ZodOptional<z.ZodString>;
+        auditVerdict: z.ZodOptional<z.ZodEnum<{
+            PASS: "PASS";
+            REJECT: "REJECT";
+        }>>;
+        auditNotes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const answerInputSchema: z.ZodObject<{
     field: z.ZodString;

package/package.json

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