@wrongstack/requirement-intake 1.0.33 → 1.0.36

package/dist/constants.d.ts

@@ -68,8 +68,6 @@ export declare const MAX_QUESTION_LENGTH = 500;
 export declare const MAX_HISTORY_ENTRIES = 200;
 /** Maximum number of pending LLM suggestions retained per record. */
 export declare const MAX_SUGGESTIONS = 100;
-/** Deterministic fallback summary length when no LLM summary is available. */
-export declare const DETERMINISTIC_SUMMARY_LENGTH = 240;
 /**
  * Default intake question catalog. Hosts may override via create options.
  * `field` values map to record properties through the answer pipeline

package/dist/index.js

@@ -1027,9 +1027,11 @@ function deriveVibeState(rawText, existingState, now = Date.now()) {
 }
 
 // src/service-helpers.ts
+function splitItems(raw) {
+  return raw.split(/[\n,;]+/).map((item) => item.trim()).filter((item) => item.length > 0);
+}
 function appendItems(target, raw) {
-  const items = raw.split(/[\n,;]+/).map((item) => item.trim()).filter((item) => item.length > 0);
-  for (const item of items) {
+  for (const item of splitItems(raw)) {
     if (!target.includes(item) && target.length < MAX_ARRAY_ITEMS) {
       target.push(item);
     }
@@ -1059,22 +1061,26 @@ var ANSWER_FIELD_MAPPING = {
   target_users: {
     set: (record, value) => {
       appendItems(record.targetUsers, value);
-    }
+    },
+    list: (record) => record.targetUsers
   },
   constraints: {
     set: (record, value) => {
       appendItems(record.constraints, value);
-    }
+    },
+    list: (record) => record.constraints
   },
   provided_context: {
     set: (record, value) => {
       appendItems(record.providedContext, value);
-    }
+    },
+    list: (record) => record.providedContext
   },
   project_component: {
     set: (record, value) => {
       appendItems(record.providedContext, value);
-    }
+    },
+    list: (record) => record.providedContext
   },
   priority: {
     set: (record, value) => {
@@ -1319,6 +1325,7 @@ function applyAnswerUpdateToRecord(record, answerId, newAnswer) {
       { field: "answerId", message: `answer not found: ${answerId}` }
     ]);
   }
+  const previous = answer.answer;
   answer.answer = newAnswer;
   answer.answeredAt = Date.now();
   const question = record.questions.find((candidate) => candidate.field === answer.field);
@@ -1327,6 +1334,18 @@ function applyAnswerUpdateToRecord(record, answerId, newAnswer) {
     question.status = "answered";
   }
   const mapping = ANSWER_FIELD_MAPPING[answer.field];
+  const list = mapping?.list?.(record);
+  if (list) {
+    const stillGiven = new Set(
+      record.answers.filter(
+        (other) => other !== answer && ANSWER_FIELD_MAPPING[other.field]?.list?.(record) === list
+      ).flatMap((other) => splitItems(other.answer))
+    );
+    for (const item of splitItems(previous)) {
+      const at = list.indexOf(item);
+      if (at >= 0 && !stillGiven.has(item)) list.splice(at, 1);
+    }
+  }
   if (mapping) {
     mapping.set(record, newAnswer);
     const sourceKey = answer.field;
@@ -1380,6 +1399,134 @@ function applyRelatedResourceToRecord(record, validated, actorId, now) {
   return resource;
 }
 
+// src/service-suggestions.ts
+async function generateSuggestions(host, id, ctx, focus) {
+  const record = await host.requireRecord(id, ctx, "suggest");
+  host.assertMutable(record, "generateSuggestions");
+  if (!host.generator) {
+    throw new IntakeSuggestionError("No LLM suggestion generator is configured on this service");
+  }
+  host.metrics.increment("intake.suggestions.requested");
+  let output;
+  try {
+    output = await host.generator.generate({ record, focus });
+  } catch (error) {
+    host.metrics.increment("intake.suggestions.failed");
+    host.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) {
+    host.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) {
+    host.metrics.increment("intake.suggestions.failed");
+    throw new IntakeSuggestionError("LLM suggestion output contained no usable proposals");
+  }
+  const hadQuestions = proposals.some((proposal2) => proposal2.kind === "question");
+  let previousStatus = record.status;
+  const updateOptions = {
+    actorId: ctx.id,
+    actorType: ctx.type,
+    action: hadQuestions ? "information_requested" : "suggestions_added"
+  };
+  const updated = await host.store.update(id, updateOptions, (next) => {
+    host.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);
+    }
+  });
+  host.metrics.increment("intake.suggestions.succeeded");
+  host.logger.info("intake", "intake.suggestions.succeeded", {
+    intakeId: updated.id,
+    projectId: updated.projectId,
+    actorId: ctx.id,
+    count: proposals.length
+  });
+  host.emit(hadQuestions ? "RequirementIntakeInformationRequested" : "RequirementIntakeUpdated", {
+    intakeId: updated.id,
+    projectId: updated.projectId,
+    actorId: ctx.id,
+    actorType: ctx.type,
+    previousStatus,
+    status: updated.status
+  });
+  return proposals;
+}
+async function acceptSuggestion(host, id, proposalId, ctx, expectedVersion) {
+  const record = await host.requireRecord(id, ctx, "accept_suggestion");
+  host.assertMutable(record, "acceptSuggestion");
+  const proposal2 = host.findSuggestion(record, proposalId);
+  if (proposal2.status !== "pending") {
+    throw new IntakeValidationError([
+      { field: "suggestionId", message: `suggestion is already ${proposal2.status}` }
+    ]);
+  }
+  return host.store.update(
+    id,
+    host.updateMeta(ctx, "suggestion_accepted", [proposal2.kind], expectedVersion),
+    (next) => {
+      host.assertMutable(next, "acceptSuggestion");
+      const target = next.llmSuggestions.find((candidate) => candidate.id === proposalId);
+      if (!target) {
+        throw new IntakeValidationError([
+          { field: "suggestionId", message: `suggestion not found: ${proposalId}` }
+        ]);
+      }
+      host.applyProposal(next, target);
+      target.status = "accepted";
+      target.resolvedAt = Date.now();
+    }
+  ).then((updated) => {
+    host.afterMutation(updated, ctx, "RequirementIntakeUpdated");
+    return updated;
+  });
+}
+async function rejectSuggestion(host, id, proposalId, ctx, expectedVersion) {
+  const record = await host.requireRecord(id, ctx, "reject_suggestion");
+  host.assertMutable(record, "rejectSuggestion");
+  host.findSuggestion(record, proposalId);
+  return host.store.update(
+    id,
+    host.updateMeta(ctx, "suggestion_rejected", [proposalId], expectedVersion),
+    (next) => {
+      host.assertMutable(next, "rejectSuggestion");
+      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) => {
+    host.afterMutation(updated, ctx, "RequirementIntakeUpdated");
+    return updated;
+  });
+}
+
 // src/service.ts
 var RequirementIntakeService = class {
   store;
@@ -1598,132 +1745,25 @@ var RequirementIntakeService = class {
   // 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");
-    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,
-      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;
+    return generateSuggestions(this.intakeSuggestionsHost(), id, ctx, focus);
   }
   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(
+    return acceptSuggestion(
+      this.intakeSuggestionsHost(),
       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([
-            { 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;
-    });
+      proposalId,
+      ctx,
+      expectedVersion
+    );
   }
   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(
+    return rejectSuggestion(
+      this.intakeSuggestionsHost(),
       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([
-            { 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;
-    });
+      proposalId,
+      ctx,
+      expectedVersion
+    );
   }
   // -------------------------------------------------------------------------
   // Lifecycle
@@ -1947,6 +1987,22 @@ var RequirementIntakeService = class {
       throw error;
     }
   }
+  intakeSuggestionsHost() {
+    void {
+      requireRecord: this.requireRecord,
+      assertMutable: this.assertMutable,
+      generator: this.generator,
+      metrics: this.metrics,
+      logger: this.logger,
+      store: this.store,
+      emit: this.emit,
+      findSuggestion: this.findSuggestion,
+      updateMeta: this.updateMeta,
+      applyProposal: this.applyProposal,
+      afterMutation: this.afterMutation
+    };
+    return this;
+  }
 };
 
 // src/types.ts

package/dist/service-helpers.d.ts

@@ -4,6 +4,8 @@ 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;
+    /** The list an append-only answer feeds; an update takes its old items back out. */
+    list?: (record: RequirementIntakeRecord) => string[];
 }>>;
 export declare function buildNewIntakeRecord(input: CreateIntakeInput, ctx: IntakeContext, now: number, catalog: readonly IntakeQuestionTemplate[]): RequirementIntakeRecord;
 export declare function assertIntakeSubmitReady(record: RequirementIntakeRecord): void;

package/dist/service-suggestions.d.ts

@@ -0,0 +1,23 @@
+import type { IntakeOperation } from './authorization.js';
+import type { IntakeLogger } from './logger.js';
+import type { IntakeMetrics } from './metrics.js';
+import type { RequirementIntakeStore, StoreUpdateOptions } from './store.js';
+import { type LlmSuggestionGenerator } from './suggestions.js';
+import type { IntakeContext, IntakeEvent, IntakeEventName, LlmSuggestionProposal, RequirementIntakeRecord } from './types.js';
+export interface IntakeSuggestionsHost {
+    requireRecord(id: string, ctx: IntakeContext, operation: IntakeOperation): Promise<RequirementIntakeRecord>;
+    assertMutable(record: RequirementIntakeRecord, action: string): void;
+    generator: LlmSuggestionGenerator | undefined;
+    metrics: IntakeMetrics;
+    logger: IntakeLogger;
+    store: RequirementIntakeStore;
+    emit(event: IntakeEventName, data: Omit<IntakeEvent, 'event' | 'timestamp'>): void;
+    findSuggestion(record: RequirementIntakeRecord, proposalId: string): LlmSuggestionProposal;
+    updateMeta(ctx: IntakeContext, action: string, fields: string[], expectedVersion?: number | undefined): StoreUpdateOptions;
+    applyProposal(record: RequirementIntakeRecord, proposal: LlmSuggestionProposal): void;
+    afterMutation(record: RequirementIntakeRecord, ctx: IntakeContext, event: IntakeEventName): void;
+}
+export declare function generateSuggestions(host: IntakeSuggestionsHost, id: string, ctx: IntakeContext, focus?: string[] | undefined): Promise<LlmSuggestionProposal[]>;
+export declare function acceptSuggestion(host: IntakeSuggestionsHost, id: string, proposalId: string, ctx: IntakeContext, expectedVersion?: number | undefined): Promise<RequirementIntakeRecord>;
+export declare function rejectSuggestion(host: IntakeSuggestionsHost, id: string, proposalId: string, ctx: IntakeContext, expectedVersion?: number | undefined): Promise<RequirementIntakeRecord>;
+//# sourceMappingURL=service-suggestions.d.ts.map

package/dist/service.d.ts

@@ -19,7 +19,7 @@ import { IntakeEventEmitter } from './events.js';
 import { type IntakeLogger } from './logger.js';
 import { type IntakeMetrics } from './metrics.js';
 import type { RequirementIntakeStore } from './store.js';
-import { type LlmSuggestionGenerator } from './suggestions.js';
+import type { LlmSuggestionGenerator } from './suggestions.js';
 import type { AddAnswerInput, AttachResourceInput, CreateIntakeInput, IntakeContext, IntakeEvent, IntakeQuestion, LlmSuggestionProposal, RequirementIntakeRecord, UpdateIntakeInput } from './types.js';
 export interface RequirementIntakeServiceOptions {
     store: RequirementIntakeStore;
@@ -85,5 +85,6 @@ export declare class RequirementIntakeService {
     private afterMutation;
     private emit;
     private guardValidation;
+    private intakeSuggestionsHost;
 }
 //# sourceMappingURL=service.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/requirement-intake",
-  "version": "1.0.33",
+  "version": "1.0.36",
   "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.33",
+    "@wrongstack/core": "1.0.36",
     "zod": "4.6.2"
   },
   "devDependencies": {
@@ -39,7 +39,7 @@
   },
   "scripts": {
     "build": "node ../../scripts/build-package.mjs",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "node ../../scripts/bun-typecheck.mjs --noEmit",
     "test": "vitest run",
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   }