@wrongstack/requirement-intake 1.0.32 → 1.0.35

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

@@ -1380,6 +1380,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 +1726,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 +1968,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-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.32",
+  "version": "1.0.35",
   "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.32",
+    "@wrongstack/core": "1.0.35",
     "zod": "4.6.2"
   },
   "devDependencies": {