@wrongstack/requirement-intake 0.306.4 → 0.307.0

package/dist/index.d.ts

@@ -18,4 +18,5 @@ export { IntakeEventEmitter } from './events.js';
 export { RequirementIntakeStore, newIntakeId, type RequirementIntakeStoreOptions, type IntakeIndexEntry, type StoreUpdateOptions, type StoreCreateResult, } from './store.js';
 export { llmSuggestionOutputSchema, validateLlmSuggestionOutput, toProposals, assertSuggestionString, type LlmSuggestionRequest, type LlmSuggestionOutput, type LlmSuggestionGenerator, type NormalizedLlmSuggestion, } from './suggestions.js';
 export { RequirementIntakeService, type RequirementIntakeServiceOptions, type IntakeCreateResult, type IntakeSubmitResult, type IntakeListFilter, } from './service.js';
+export { VIBE_TAG_REGEX, hasVibeTag, stripVibeTag, deriveVibeState, type VibeProtocolStage, type VibeProtocolState, } from './vibe.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -878,8 +878,45 @@ function assertSuggestionString(value, label, max) {
   return value;
 }
 
-// src/service.ts
+// src/service-helpers.ts
 import { ulid as ulid4 } from "@wrongstack/core/utils";
+
+// src/vibe.ts
+var VIBE_TAG_REGEX = /\[VIBE\]/i;
+function hasVibeTag(text) {
+  if (!text) return false;
+  return VIBE_TAG_REGEX.test(text);
+}
+function stripVibeTag(text) {
+  return text.replace(VIBE_TAG_REGEX, "").replace(/[ \t]{2,}/g, " ").trim();
+}
+function deriveVibeState(rawText, existingState, now = Date.now()) {
+  const containsTag = hasVibeTag(rawText);
+  if (existingState?.isVibeMode) {
+    return {
+      ...existingState,
+      isVibeMode: true
+    };
+  }
+  if (containsTag) {
+    return {
+      isVibeMode: true,
+      detectedAt: now,
+      stage: "synthesizer"
+    };
+  }
+  return void 0;
+}
+
+// src/service-helpers.ts
+function appendItems(target, raw) {
+  const items = raw.split(/[\n,;]+/).map((item) => item.trim()).filter((item) => item.length > 0);
+  for (const item of items) {
+    if (!target.includes(item) && target.length < MAX_ARRAY_ITEMS) {
+      target.push(item);
+    }
+  }
+}
 var ANSWER_FIELD_MAPPING = {
   business_goal: {
     set: (record, value) => {
@@ -931,11 +968,294 @@ var ANSWER_FIELD_MAPPING = {
     }
   }
 };
-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));
+function buildNewIntakeRecord(input, ctx, now, catalog) {
+  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
+  }));
+  const vibeState = deriveVibeState(
+    input.originalRequest,
+    input.vibeProtocol ?? (input.isVibeMode ? { isVibeMode: true, detectedAt: now, stage: "synthesizer" } : void 0),
+    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,
+    ...vibeState ? { isVibeMode: true, vibeProtocol: vibeState } : {},
+    ...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, 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
+  };
+}
+function assertIntakeSubmitReady(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) {
+    throw new IntakeValidationError(issues, "Requirement intake is not ready for submission");
+  }
+}
+function findSuggestionProposal(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;
+}
+function applySuggestionProposal(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;
+    }
+  }
+}
+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;
+  }
+}
+function applyAnswerToRecord(record, validated, actorId, now) {
+  const matchingQuestion = record.questions.find((candidate) => candidate.field === validated.field);
+  const answer = {
+    id: `${ANSWER_ID_PREFIX}${ulid4()}`,
+    field: validated.field,
+    question: validated.question ?? matchingQuestion?.question ?? validated.field,
+    answer: validated.answer,
+    answeredBy: actorId,
+    answeredAt: now,
+    source: "user"
+  };
+  record.answers.push(answer);
+  markQuestionAnswered(record, validated.field, validated.answer);
+  const mapping = ANSWER_FIELD_MAPPING[validated.field];
+  if (mapping) {
+    mapping.set(record, validated.answer);
+    const sourceKey = validated.field;
+    record.fieldSources[sourceKey] = "user";
+  }
+  return answer;
+}
+function applyAnswerUpdateToRecord(record, answerId, newAnswer) {
+  const answer = record.answers.find((candidate) => candidate.id === answerId);
+  if (!answer) {
+    throw new IntakeValidationError([
+      { field: "answerId", message: `answer not found: ${answerId}` }
+    ]);
+  }
+  answer.answer = newAnswer;
+  answer.answeredAt = Date.now();
+  const question = record.questions.find((candidate) => candidate.field === answer.field);
+  if (question) {
+    question.answer = newAnswer;
+    question.status = "answered";
+  }
 }
+function applyAttachmentToRecord(record, validated, actorId, now) {
+  if (record.attachments.length >= MAX_ATTACHMENTS) {
+    throw new IntakeValidationError([
+      { field: "attachments", message: `maximum of ${MAX_ATTACHMENTS} attachments reached` }
+    ]);
+  }
+  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: actorId,
+    addedAt: now
+  };
+  record.attachments.push(attachment);
+  record.fieldSources.attachments = "user";
+  markQuestionAnswered(record, "attachments", attachment.name);
+  return attachment;
+}
+function applyRelatedResourceToRecord(record, validated, actorId, now) {
+  if (record.relatedResources.length >= MAX_RELATED_RESOURCES) {
+    throw new IntakeValidationError([
+      {
+        field: "relatedResources",
+        message: `maximum of ${MAX_RELATED_RESOURCES} related resources reached`
+      }
+    ]);
+  }
+  const resource = {
+    id: `${RELATED_RESOURCE_ID_PREFIX}${ulid4()}`,
+    kind: validated.relatedResource.kind,
+    reference: validated.relatedResource.reference,
+    title: validated.relatedResource?.title,
+    source: "user",
+    addedBy: actorId,
+    addedAt: now
+  };
+  record.relatedResources.push(resource);
+  record.fieldSources.related_resources = "user";
+  markQuestionAnswered(record, "related_resources", resource.reference);
+  return resource;
+}
+
+// src/service.ts
 var RequirementIntakeService = class {
   store;
   authorizer;
@@ -1057,6 +1377,8 @@ var RequirementIntakeService = class {
       if (validated.providedContext !== void 0)
         next.providedContext = [...validated.providedContext];
       if (validated.metadata !== void 0) next.metadata = validated.metadata;
+      if (validated.isVibeMode !== void 0) next.isVibeMode = validated.isVibeMode;
+      if (validated.vibeProtocol !== void 0) next.vibeProtocol = validated.vibeProtocol;
       markUserSources(next, changedKeys);
     }).then((updated) => {
       this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
@@ -1072,25 +1394,7 @@ var RequirementIntakeService = class {
       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";
-        }
+        applyAnswerToRecord(next, validated, ctx.id, Date.now());
       }
     ).then((updated) => {
       this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
@@ -1107,19 +1411,7 @@ var RequirementIntakeService = class {
       })
     );
     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";
-      }
+      applyAnswerUpdateToRecord(next, answerId, validated.answer);
     }).then((updated) => {
       this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
       return updated;
@@ -1131,60 +1423,22 @@ var RequirementIntakeService = class {
     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);
+          applyAttachmentToRecord(next, validated, ctx.id, now);
         }
       ).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);
+        applyRelatedResourceToRecord(next, validated, ctx.id, now);
       }
     ).then((updated) => {
       this.afterMutation(updated, ctx, "RequirementIntakeUpdated");
@@ -1452,73 +1706,7 @@ var RequirementIntakeService = class {
   // 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
-    };
+    return buildNewIntakeRecord(input, ctx, now, this.catalog);
   }
   async requireRecord(id, ctx, operation) {
     const record = await this.store.load(id);
@@ -1547,99 +1735,20 @@ var RequirementIntakeService = class {
     }
   }
   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");
+    try {
+      assertIntakeSubmitReady(record);
+    } catch (error) {
+      if (error instanceof IntakeValidationError) {
+        this.metrics.increment("intake.validation_failure");
+      }
+      throw error;
     }
   }
   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;
+    return findSuggestionProposal(record, proposalId);
   }
   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;
-      }
-    }
+    applySuggestionProposal(record, proposal2);
   }
   updateMeta(ctx, action, fields, expectedVersion) {
     return {
@@ -1678,41 +1787,6 @@ var RequirementIntakeService = class {
     }
   }
 };
-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,
@@ -1765,6 +1839,7 @@ export {
   RequirementIntakeStore,
   SUGGESTION_KINDS,
   SUGGESTION_STATUSES,
+  VIBE_TAG_REGEX,
   answerInputSchema,
   assertSuggestionString,
   assertTransition,
@@ -1773,8 +1848,10 @@ export {
   buildInitialQuestions,
   canTransition,
   createIntakeSchema,
+  deriveVibeState,
   deterministicSummary,
   deterministicTitle,
+  hasVibeTag,
   isBlank,
   isKnownStatus,
   isMutableStatus,
@@ -1789,6 +1866,7 @@ export {
   questionTemplateInputSchema,
   relatedResourceInputSchema,
   requestTypeSchema,
+  stripVibeTag,
   toProposals,
   updateIntakeSchema,
   upsertQuestion,

package/dist/service-helpers.d.ts

@@ -0,0 +1,19 @@
+import { type IntakeQuestionTemplate } from './constants.js';
+import type { AddAnswerInput, AttachResourceInput, CreateIntakeInput, IntakeAnswer, IntakeAttachment, IntakeContext, LlmSuggestionProposal, RelatedResource, RequirementIntakeRecord } from './types.js';
+export declare function appendItems(target: string[], raw: string): void;
+/** Answer fields that also update a record property. */
+export declare const ANSWER_FIELD_MAPPING: Readonly<Record<string, {
+    set: (record: RequirementIntakeRecord, value: string) => void;
+}>>;
+export declare function buildNewIntakeRecord(input: CreateIntakeInput, ctx: IntakeContext, now: number, catalog: readonly IntakeQuestionTemplate[]): RequirementIntakeRecord;
+export declare function assertIntakeSubmitReady(record: RequirementIntakeRecord): void;
+export declare function findSuggestionProposal(record: RequirementIntakeRecord, proposalId: string): LlmSuggestionProposal;
+export declare function applySuggestionProposal(record: RequirementIntakeRecord, proposal: LlmSuggestionProposal): void;
+export declare function applyOptionalString(record: RequirementIntakeRecord, field: 'businessGoal' | 'expectedOutcome' | 'scopeNotes', value: string | undefined): void;
+export declare function markUserSources(record: RequirementIntakeRecord, changedKeys: string[]): void;
+export declare function markQuestionAnswered(record: RequirementIntakeRecord, field: string, value: string): void;
+export declare function applyAnswerToRecord(record: RequirementIntakeRecord, validated: AddAnswerInput, actorId: string, now: number): IntakeAnswer;
+export declare function applyAnswerUpdateToRecord(record: RequirementIntakeRecord, answerId: string, newAnswer: string): void;
+export declare function applyAttachmentToRecord(record: RequirementIntakeRecord, validated: AttachResourceInput, actorId: string, now: number): IntakeAttachment;
+export declare function applyRelatedResourceToRecord(record: RequirementIntakeRecord, validated: AttachResourceInput, actorId: string, now: number): RelatedResource;
+//# sourceMappingURL=service-helpers.d.ts.map

package/dist/service.d.ts

@@ -1,3 +1,18 @@
+/**
+ * Requirements Intake — service.
+ *
+ * The single entry point for all intake operations. Enforces:
+ *  - deterministic validation of every input (untrusted text stays data),
+ *  - authorization on every operation (fail closed),
+ *  - lifecycle transitions via application logic only,
+ *  - optimistic concurrency (expectedVersion),
+ *  - idempotent create (idempotency key) and submit,
+ *  - source tracking (user / llm / deterministic),
+ *  - domain events + structured logs + metrics with safe fields only.
+ *
+ * The original request is immutable after creation: no API path can change
+ * `originalRequest`, and LLM suggestions can never write to it.
+ */
 import { type IntakeQuestionTemplate, type IntakeStatus } from './constants.js';
 import type { IntakeAuthorizer } from './authorization.js';
 import { IntakeEventEmitter } from './events.js';

package/dist/types.d.ts

@@ -6,6 +6,7 @@
  * generated value separate, source-annotated, and user-editable.
  */
 import type { IntakeAttachmentKind, IntakeField, IntakeFieldSource, IntakePriority, IntakeQuestionStatus, IntakeStatus, RelatedResourceKind, RequestType, SuggestionKind, SuggestionStatus } from './constants.js';
+import type { VibeProtocolState } from './vibe.js';
 /** Actor identity used for authorization and audit. */
 export interface IntakeActor {
     /** Stable actor id (user id, agent id, or automation id). */
@@ -116,6 +117,10 @@ export interface RequirementIntakeRecord {
     questions: IntakeQuestion[];
     llmSuggestions: LlmSuggestionProposal[];
     metadata: Record<string, unknown>;
+    /** True when the request is processed under the Three-Stage VIBE Verification Protocol. */
+    isVibeMode?: boolean | undefined;
+    /** Persisted state of the VIBE protocol pipeline (Spec-Synthesizer -> Coder -> Auditor). */
+    vibeProtocol?: VibeProtocolState | undefined;
     /** Source annotation per record field ('user' | 'llm' | 'deterministic'). */
     fieldSources: Partial<Record<IntakeField, IntakeFieldSource>>;
     /** Raw idempotency key used at creation (kept for diagnostics). */
@@ -151,6 +156,10 @@ export interface CreateIntakeInput {
     attachments?: IntakeAttachmentInput[] | undefined;
     relatedResources?: RelatedResourceInput[] | undefined;
     metadata?: Record<string, unknown> | undefined;
+    /** Explicit override for Vibe Mode; if omitted, automatically detected from originalRequest. */
+    isVibeMode?: boolean | undefined;
+    /** Optional initial vibe state if resuming an existing cycle. */
+    vibeProtocol?: VibeProtocolState | undefined;
     /** Idempotent-create key: same key + project returns the existing record. */
     idempotencyKey?: string | undefined;
     /**
@@ -191,6 +200,8 @@ export interface UpdateIntakeInput {
     constraints?: string[] | undefined;
     providedContext?: string[] | undefined;
     metadata?: Record<string, unknown> | undefined;
+    isVibeMode?: boolean | undefined;
+    vibeProtocol?: VibeProtocolState | undefined;
 }
 /** Payload for answering an intake question. */
 export interface AddAnswerInput {

package/dist/vibe.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Requirements Intake — VIBE Three-Stage Verification Protocol.
+ *
+ * Provides detection, tag parsing, and persistent state management for requests
+ * marked with the `[VIBE]` protocol trigger anywhere in the prompt text.
+ *
+ * When `[VIBE]` is detected, it locks the task into the Three-Stage
+ * Verification Protocol (Spec-Synthesizer -> Coder -> Auditor) and ensures
+ * the state is preserved across iterative refining and updates.
+ */
+export declare const VIBE_TAG_REGEX: RegExp;
+export type VibeProtocolStage = 'synthesizer' | 'coder' | 'auditor' | 'passed';
+export interface VibeProtocolState {
+    /** True whenever [VIBE] was present in the prompt or preserved across refinements. */
+    isVibeMode: boolean;
+    detectedAt: number;
+    /** Active stage in the verification protocol. */
+    stage: VibeProtocolStage;
+    /** Structured output from Spec-Synthesizer. */
+    synthesizedSpec?: string | undefined;
+    /** Generated implementation contract or code diff. */
+    coderContract?: string | undefined;
+    /** Independent verification decision from Auditor. */
+    auditVerdict?: 'PASS' | 'REJECT' | undefined;
+    /** Detailed audit check results or revision requests. */
+    auditNotes?: string[] | undefined;
+}
+/**
+ * Checks if the given text contains the `[VIBE]` tag (case-insensitive)
+ * anywhere in the string.
+ */
+export declare function hasVibeTag(text: string | undefined | null): boolean;
+/**
+ * Safely strips the `[VIBE]` tag from the text for normalized display,
+ * preserving all other content and trimming extraneous whitespace.
+ */
+export declare function stripVibeTag(text: string): string;
+/**
+ * Derives or preserves Vibe Protocol state for an intake record.
+ * If the record was already in Vibe mode, it remains in Vibe mode across
+ * refinements even if subsequent messages omit the tag.
+ */
+export declare function deriveVibeState(rawText: string, existingState?: VibeProtocolState | undefined, now?: number): VibeProtocolState | undefined;
+//# sourceMappingURL=vibe.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/requirement-intake",
-  "version": "0.306.4",
+  "version": "0.307.0",
   "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": {
@@ -28,10 +28,10 @@
   ],
   "dependencies": {
     "zod": "4.4.3",
-    "@wrongstack/core": "0.306.4"
+    "@wrongstack/core": "0.307.0"
   },
   "devDependencies": {
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "typescript": "^7.0.2"
   },
   "publishConfig": {