@suss/intent-ir 0.33.0 → 0.34.0

package/dist/index.cjs

@@ -21,8 +21,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ACCEPTS_NULL: () => ACCEPTS_NULL,
+  AlwaysEffectSchema: () => AlwaysEffectSchema,
   BodyShapeSchema: () => BodyShapeSchema,
   BoundarySchema: () => BoundarySchema,
+  ChangeListSchema: () => ChangeListSchema,
+  EffectLineSchema: () => EffectLineSchema,
+  EffectOutcomeSchema: () => EffectOutcomeSchema,
+  INPUT_SOURCE_PREFIX: () => INPUT_SOURCE_PREFIX,
   IntentDocSchema: () => IntentDocSchema,
   IntentFindingKindSchema: () => IntentFindingKindSchema,
   IntentFindingSchema: () => IntentFindingSchema,
@@ -30,101 +35,57 @@ __export(index_exports, {
   IntentFindingSuppressionSchema: () => IntentFindingSuppressionSchema,
   IntentRefSchema: () => IntentRefSchema,
   IntentSourceSchema: () => IntentSourceSchema,
+  NODE_ID_SEPARATOR: () => NODE_ID_SEPARATOR,
+  TEST_TITLE_SEPARATOR: () => import_ir_core.TEST_TITLE_SEPARATOR,
   blanksLeftEmpty: () => blanksLeftEmpty,
+  changeListToSummary: () => changeListToSummary,
   fillBlanks: () => fillBlanks,
   intentDocToSummary: () => intentDocToSummary,
+  parseChangeList: () => parseChangeList,
   toBoundaryBinding: () => toBoundaryBinding,
+  toCoveringTest: () => toCoveringTest,
+  toIntentEffect: () => toIntentEffect,
   toReceives: () => toReceives
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/findings.ts
-var import_zod = require("zod");
-var IntentFindingKindSchema = import_zod.z.enum([
-  // System intent (kind: boundary) vs code:
-  "uncoveredOutcome",
-  // intent declares an outcome the code never produces
-  "unimplementedBoundary",
-  // intent boundary has no implementing code at all
-  "outcomeShapeMismatch",
-  // a matched outcome whose body shapes disagree
-  "undeclaredOutcome",
-  // code produces a REST status the intent doesn't declare
-  "unkeyableBoundary",
-  // intent boundary can't be keyed, so it can't be checked
-  "renamedBoundary",
-  // a declared store vanished and an undeclared one of the same system appeared with the same outcomes
-  // What the boundary is handed: the `receives` block against the paths
-  // the unit reads off its input.
-  "unreadInputField",
-  // intent declares a field no transition of the unit reads
-  "undeclaredInputRead",
-  // the unit reads a path the receives block does not list
-  // Outcome intent (kind: prd), scenario link coverage against system
-  // intent. These concretise the proposal's "scenario not linked /
-  // dangling / ambiguous" set (design/proposals/intent-specs.md);
-  // the proposal deferred concrete names to implementation time.
-  "unlinkedScenario",
-  // scenario carries no structured link (info — a valid pending state)
-  "danglingScenarioLink",
-  // link names an intent / outcome no boundary intent declares
-  "ambiguousScenarioLink",
-  // link resolves to two or more boundary intents sharing the name
-  // The same coverage question asked the other way: which declared
-  // behaviour has nobody written a reason for.
-  "undescribedOutcome"
-  // a declared outcome no PRD scenario links to (info)
-]);
-var IntentFindingSeveritySchema = import_zod.z.enum(["error", "warning", "info"]);
-var IntentRefSchema = import_zod.z.object({
-  /** The intent doc's `name` (boundary) or `title` (prd). */
-  name: import_zod.z.string(),
-  /** The declared outcome id, when the finding is outcome-specific. */
-  outcomeId: import_zod.z.string().optional()
-});
-var IntentFindingSuppressionSchema = import_zod.z.object({
-  /** The rule's human-written justification. */
-  reason: import_zod.z.string(),
-  effect: import_zod.z.enum(["mark", "downgrade", "hide"]),
-  /** Original severity, present only when effect is "downgrade". */
-  originalSeverity: IntentFindingSeveritySchema.optional()
-});
-var IntentFindingSchema = import_zod.z.object({
-  kind: IntentFindingKindSchema,
-  severity: IntentFindingSeveritySchema,
-  /**
-   * Human-readable boundary label: e.g. `GET /users/:id` or
-   * `fn:@suss/cli::contract`. The key the intent and code were paired on.
-   */
-  boundary: import_zod.z.string(),
-  /** The intent side of the finding. */
-  intent: IntentRefSchema,
-  /**
-   * The matched code summary as `${file}::${name}`, when the finding
-   * concerns a specific implementation. Absent for unimplementedBoundary.
-   */
-  code: import_zod.z.string().optional(),
-  /**
-   * PRD-scenario extension: present only on outcome-intent findings
-   * (unlinkedScenario / danglingScenarioLink / ambiguousScenarioLink).
-   * Identifies the scenario (by its optional title) and the qualified
-   * outcome ref (`<intent-name>.<outcome-id>`) that failed to resolve.
-   * The peer / boundary findings leave it unset. This is the "intent
-   * finding extension" decision 2 of the proposal anticipated.
-   */
-  scenario: import_zod.z.object({
-    title: import_zod.z.string().optional(),
-    link: import_zod.z.string().optional()
-  }).optional(),
-  message: import_zod.z.string(),
-  /** Present when a .sussignore rule matched this finding. */
-  suppressed: IntentFindingSuppressionSchema.optional()
-});
+// src/changeList.ts
+var import_zod2 = require("zod");
 
 // src/schema.ts
-var import_zod2 = require("zod");
+var import_zod = require("zod");
+var import_ir_core2 = require("@suss/ir-core");
+
+// src/coveringTest.ts
 var import_ir_core = require("@suss/ir-core");
-var IntentSourceSchema = import_zod2.z.enum(["author", "inferred", "inferred, curated"]).default("author").describe(
+var NODE_ID_SEPARATOR = "::";
+function toCoveringTest(spelledAs) {
+  if (!spelledAs.includes(import_ir_core.TEST_TITLE_SEPARATOR)) {
+    return nodeIdSpelling(spelledAs);
+  }
+  const [file, ...titles] = spelledAs.split(import_ir_core.TEST_TITLE_SEPARATOR);
+  return { spelledAs, file: file.trim(), titles };
+}
+function nodeIdSpelling(spelledAs) {
+  const parts = spelledAs.trim().split(NODE_ID_SEPARATOR);
+  const last = parts.length - 1;
+  parts[last] = parts[last].replace(/\[.*\]$/, "");
+  let fileAt = last;
+  while (fileAt >= 0 && !/[./]/.test(parts[fileAt])) {
+    fileAt -= 1;
+  }
+  if (fileAt < 0) {
+    return { spelledAs, file: spelledAs.trim(), titles: [] };
+  }
+  return {
+    spelledAs,
+    file: parts.slice(0, fileAt + 1).join(NODE_ID_SEPARATOR),
+    titles: parts.slice(fileAt + 1)
+  };
+}
+
+// src/schema.ts
+var IntentSourceSchema = import_zod.z.enum(["author", "inferred", "inferred, curated"]).default("author").describe(
   "Where the document came from: somebody wrote it, suss inferred it, or suss inferred it and somebody has since curated it."
 );
 var UNCURATED_SOURCE = "inferred";
@@ -160,7 +121,7 @@ function fillBlanks(doc, blanks) {
   }));
   return filled;
 }
-var PrimitiveTypeName = import_zod2.z.enum([
+var PrimitiveTypeName = import_zod.z.enum([
   "string",
   "integer",
   "number",
@@ -168,161 +129,191 @@ var PrimitiveTypeName = import_zod2.z.enum([
   "null",
   "unknown"
 ]);
-var ShapeSchema = import_zod2.z.lazy(
-  () => import_zod2.z.union([
-    import_zod2.z.object({ type: PrimitiveTypeName }),
-    import_zod2.z.object({ type: import_zod2.z.literal("array"), items: ShapeSchema.optional() }),
-    import_zod2.z.object({
-      type: import_zod2.z.literal("object"),
-      properties: import_zod2.z.record(import_zod2.z.string(), ShapeSchema).optional(),
-      required: import_zod2.z.array(import_zod2.z.string()).optional()
+var ShapeSchema = import_zod.z.lazy(
+  () => import_zod.z.union([
+    import_zod.z.object({ type: PrimitiveTypeName }),
+    import_zod.z.object({ type: import_zod.z.literal("array"), items: ShapeSchema.optional() }),
+    import_zod.z.object({
+      type: import_zod.z.literal("object"),
+      properties: import_zod.z.record(import_zod.z.string(), ShapeSchema).optional(),
+      required: import_zod.z.array(import_zod.z.string()).optional()
+    }),
+    import_zod.z.strictObject({
+      const: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()])
+    }),
+    import_zod.z.strictObject({
+      properties: import_zod.z.record(import_zod.z.string(), ShapeSchema),
+      required: import_zod.z.array(import_zod.z.string()).optional()
     })
   ])
 );
-var BodyShapeSchema = import_zod2.z.union([
+var BodyShapeSchema = import_zod.z.union([
   ShapeSchema,
-  import_zod2.z.object({
-    properties: import_zod2.z.record(import_zod2.z.string(), ShapeSchema).optional(),
-    required: import_zod2.z.array(import_zod2.z.string()).optional()
+  import_zod.z.object({
+    properties: import_zod.z.record(import_zod.z.string(), ShapeSchema).optional(),
+    required: import_zod.z.array(import_zod.z.string()).optional()
   })
 ]);
 var REQUIRED = {
-  required: import_zod2.z.boolean().default(false).describe("Whether the boundary needs this field.")
+  required: import_zod.z.boolean().default(false).describe("Whether the boundary needs this field.")
 };
-var InputFieldSchema = import_zod2.z.union([
-  import_zod2.z.strictObject({ ...REQUIRED, type: PrimitiveTypeName }),
-  import_zod2.z.strictObject({
+var InputFieldSchema = import_zod.z.union([
+  import_zod.z.strictObject({ ...REQUIRED, type: PrimitiveTypeName }),
+  import_zod.z.strictObject({
     ...REQUIRED,
-    type: import_zod2.z.literal("array"),
+    type: import_zod.z.literal("array"),
     items: ShapeSchema.optional()
   }),
-  import_zod2.z.strictObject({
+  import_zod.z.strictObject({
     ...REQUIRED,
-    type: import_zod2.z.literal("object"),
-    properties: import_zod2.z.record(import_zod2.z.string(), ShapeSchema).optional()
+    type: import_zod.z.literal("object"),
+    properties: import_zod.z.record(import_zod.z.string(), ShapeSchema).optional()
   }),
-  import_zod2.z.strictObject(REQUIRED)
+  import_zod.z.strictObject(REQUIRED)
 ]);
-var ReceivesSchema = import_zod2.z.record(import_zod2.z.string().min(1), InputFieldSchema).describe(
+var ReceivesSchema = import_zod.z.record(import_zod.z.string().min(1), InputFieldSchema).describe(
   "The fields the boundary is handed, by field name. On a function-call boundary a name is a parameter, on a message bus it is a field of the message body."
 ).optional();
-var RestReceivesSchema = import_zod2.z.strictObject({
-  headers: import_zod2.z.record(import_zod2.z.string().min(1), InputFieldSchema).describe("The request headers the boundary depends on, by name.").optional(),
-  query: import_zod2.z.record(import_zod2.z.string().min(1), InputFieldSchema).describe("The query-string parameters the boundary depends on, by name.").optional(),
-  params: import_zod2.z.record(import_zod2.z.string().min(1), InputFieldSchema).describe("The path parameters the boundary depends on, by name.").optional(),
+var RestReceivesSchema = import_zod.z.strictObject({
+  headers: import_zod.z.record(import_zod.z.string().min(1), InputFieldSchema).describe("The request headers the boundary depends on, by name.").optional(),
+  query: import_zod.z.record(import_zod.z.string().min(1), InputFieldSchema).describe("The query-string parameters the boundary depends on, by name.").optional(),
+  params: import_zod.z.record(import_zod.z.string().min(1), InputFieldSchema).describe("The path parameters the boundary depends on, by name.").optional(),
   body: BodyShapeSchema.describe(
     "The shape of the request body the boundary depends on."
   ).optional()
 }).describe("The parts of the request the boundary depends on.").optional();
-var RestBoundarySchema = import_zod2.z.strictObject({
-  transport: import_zod2.z.literal("http").default("http"),
-  semantics: import_zod2.z.literal("rest"),
-  method: import_zod2.z.string().min(1).describe("The HTTP method the route handles."),
-  path: import_zod2.z.string().min(1).describe("The route path, written the way the framework declares it."),
+var RestBoundarySchema = import_zod.z.strictObject({
+  transport: import_zod.z.literal("http").default("http"),
+  semantics: import_zod.z.literal("rest"),
+  method: import_zod.z.string().min(1).describe("The HTTP method the route handles."),
+  path: import_zod.z.string().min(1).describe("The route path, written the way the framework declares it."),
   receives: RestReceivesSchema
 });
-var FunctionCallBoundarySchema = import_zod2.z.strictObject({
-  transport: import_zod2.z.string().default("in-process"),
-  semantics: import_zod2.z.literal("function-call"),
-  module: import_zod2.z.string().describe(
+var FunctionCallBoundarySchema = import_zod.z.strictObject({
+  transport: import_zod.z.string().default("in-process"),
+  semantics: import_zod.z.literal("function-call"),
+  module: import_zod.z.string().describe(
     "The repo-relative module path, when the boundary is a unit inside this repository."
   ).optional(),
-  exportName: import_zod2.z.string().describe("The name the module or package exports the function under.").optional(),
-  package: import_zod2.z.string().describe(
+  exportName: import_zod.z.string().describe("The name the module or package exports the function under.").optional(),
+  package: import_zod.z.string().describe(
     "The package name, when the boundary is something a package publishes."
   ).optional(),
-  exportPath: import_zod2.z.array(import_zod2.z.string()).describe(
+  exportPath: import_zod.z.array(import_zod.z.string()).describe(
     "The path to the export inside the package: the sub-path, then any nested names."
   ).optional(),
   receives: ReceivesSchema
 });
-var MessageBusBoundarySchema = import_zod2.z.strictObject({
-  semantics: import_zod2.z.literal("message-bus"),
-  messageBus: import_ir_core.MessageBusSemanticsSchema.shape.messageBus.describe(
+var MessageBusBoundarySchema = import_zod.z.strictObject({
+  semantics: import_zod.z.literal("message-bus"),
+  messageBus: import_ir_core2.MessageBusSemanticsSchema.shape.messageBus.describe(
     "Which bus carries the message, in the name suss gives that bus."
   ),
-  channel: import_ir_core.MessageBusSemanticsSchema.shape.channel.default(null).describe(
+  channel: import_ir_core2.MessageBusSemanticsSchema.shape.channel.default(null).describe(
     "The queue or topic the message travels on. Null when the document does not name one."
   ),
   receives: ReceivesSchema
 });
-var StorageBoundarySchema = import_zod2.z.strictObject({
-  semantics: import_zod2.z.literal("storage"),
-  storageSystem: import_ir_core.StorageSemanticsSchema.shape.storageSystem.default(null).describe(
+var StorageBoundarySchema = import_zod.z.strictObject({
+  semantics: import_zod.z.literal("storage"),
+  storageSystem: import_ir_core2.StorageSemanticsSchema.shape.storageSystem.default(null).describe(
     "Which store this is: postgresql, aws.dynamodb, s3, and so on. Null when the document does not say which engine."
   ),
-  scope: import_ir_core.StorageSemanticsSchema.shape.scope.default("default").describe(
+  scope: import_ir_core2.StorageSemanticsSchema.shape.scope.default("default").describe(
     "The ORM, schema or deployment scope the container is in. A setup with one database uses default."
   ),
-  container: import_ir_core.StorageSemanticsSchema.shape.container.default(null).describe(
+  container: import_ir_core2.StorageSemanticsSchema.shape.container.default(null).describe(
     "The table, bucket, collection or index. Null when the document does not name one."
   ),
-  accessPath: import_ir_core.StorageSemanticsSchema.shape.accessPath.default(null).describe(
+  accessPath: import_ir_core2.StorageSemanticsSchema.shape.accessPath.default(null).describe(
     "A secondary way into the container, such as a DynamoDB index or an Elasticsearch alias. Null means the container's own primary way in."
   ),
   receives: ReceivesSchema
 });
-var UnitInvocationBoundarySchema = import_zod2.z.strictObject({
-  semantics: import_zod2.z.literal("unit-invocation"),
-  deploymentTarget: import_ir_core.UnitInvocationSemanticsSchema.shape.deploymentTarget.describe(
+var UnitInvocationBoundarySchema = import_zod.z.strictObject({
+  semantics: import_zod.z.literal("unit-invocation"),
+  deploymentTarget: import_ir_core2.UnitInvocationSemanticsSchema.shape.deploymentTarget.describe(
     "What sort of deployed thing this is: a Lambda function, an ECS task's container, a plain container, a k8s deployment or an edge worker."
   ),
-  instanceName: import_ir_core.UnitInvocationSemanticsSchema.shape.instanceName.default(null).describe(
+  instanceName: import_ir_core2.UnitInvocationSemanticsSchema.shape.instanceName.default(null).describe(
     "The name the deployment medium knows the unit by, such as a CloudFormation logical id. Null when the document does not name one."
   ),
   receives: ReceivesSchema
 });
-var BoundarySchema = import_zod2.z.discriminatedUnion("semantics", [
+var BoundarySchema = import_zod.z.discriminatedUnion("semantics", [
   RestBoundarySchema,
   FunctionCallBoundarySchema,
   MessageBusBoundarySchema,
   StorageBoundarySchema,
   UnitInvocationBoundarySchema
 ]);
-var ResponseOutcomeSchema = import_zod2.z.object({
-  status: import_zod2.z.number().int().min(100).max(599).describe("The HTTP status code the response carries."),
+var ResponseOutcomeSchema = import_zod.z.object({
+  status: import_zod.z.number().int().min(100).max(599).describe("The HTTP status code the response carries."),
   body: BodyShapeSchema.describe("The shape of the response body.").optional()
 });
-var ReturnsOutcomeSchema = import_zod2.z.object({
+var ReturnsOutcomeSchema = import_zod.z.object({
   body: BodyShapeSchema.describe("The shape of the returned value.").optional()
 });
-var ThrowsOutcomeSchema = import_zod2.z.object({
-  errorType: import_zod2.z.string().describe("The name of the error class this outcome raises.").optional()
+var ThrowsOutcomeSchema = import_zod.z.object({
+  errorType: import_zod.z.string().describe("The name of the error class this outcome raises.").optional()
 });
 function emptyIfNull(schema) {
-  return import_zod2.z.preprocess((v) => v === null ? {} : v, schema).meta({ [ACCEPTS_NULL]: true });
+  return import_zod.z.preprocess((v) => v === null ? {} : v, schema).meta({ [ACCEPTS_NULL]: true });
 }
 var ACCEPTS_NULL = "x-suss-accepts-null";
-var ONE_OR_MORE = import_zod2.z.union([
-  import_zod2.z.string().min(1),
-  import_zod2.z.array(import_zod2.z.string().min(1)).min(1)
+var INPUT_SOURCE_PREFIX = "input.";
+var SourcesSchema = import_zod.z.record(
+  import_zod.z.string().min(1),
+  import_zod.z.string().regex(/^input\.[^.]+(\.[^.]+)*$/, {
+    message: "a source is written input.<path>, such as input.headers.x-tenant-id or input.body.email"
+  })
+).describe(
+  "Where the value of a column the line lists under fields or by comes from, keyed by the column: input.<path>, spelled the way receives spells it."
+);
+var ONE_OR_MORE = import_zod.z.union([
+  import_zod.z.string().min(1),
+  import_zod.z.array(import_zod.z.string().min(1)).min(1)
 ]);
-var EFFECT_BY_VERB = import_ir_core.EffectRelationSchema.options.map(
-  (verb) => import_zod2.z.strictObject({
-    [verb]: import_zod2.z.string().min(1),
-    fields: import_zod2.z.array(import_zod2.z.string().min(1)).min(1).optional(),
-    by: ONE_OR_MORE.optional()
+function effectByVerb(extra = {}) {
+  return import_ir_core2.EffectRelationSchema.options.map(
+    (verb) => import_zod.z.strictObject({
+      [verb]: import_zod.z.string().min(1),
+      fields: import_zod.z.array(import_zod.z.string().min(1)).min(1).optional(),
+      by: ONE_OR_MORE.optional(),
+      shape: BodyShapeSchema.describe(
+        "The shape of what the effect writes, such as the report a command prints."
+      ).optional(),
+      ...extra
+    })
+  );
+}
+var EffectLineSchema = import_zod.z.union(effectByVerb());
+var EffectOutcomeSchema = import_zod.z.union(
+  effectByVerb({ from: SourcesSchema.optional() })
+);
+var AlwaysEffectSchema = import_zod.z.union(
+  effectByVerb({
+    except: import_zod.z.array(import_zod.z.string().min(1)).min(1).describe("The ids of the outcomes that do not have to have the effect.").optional()
   })
 );
-var EffectOutcomeSchema = import_zod2.z.union(EFFECT_BY_VERB);
 var CHECKS = {
   /** What a lookup came back with. */
-  finds: import_zod2.z.enum(["nothing", "something"]),
+  finds: import_zod.z.enum(["nothing", "something"]),
   /** What state the value was in: `set`, `missing`, `null`, `a string`. */
-  is: import_zod2.z.string().min(1),
+  is: import_zod.z.string().min(1),
   /** The value it was equal to. */
-  equals: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean(), import_zod2.z.null()]),
+  equals: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()]),
   /** A property it had. */
-  has: import_zod2.z.string().min(1)
+  has: import_zod.z.string().min(1)
 };
 var SUBJECT_KEYS = [
-  ...import_ir_core.EffectRelationSchema.options,
+  ...import_ir_core2.EffectRelationSchema.options,
   "input"
 ];
 var WHEN_CLAUSE_BY_SUBJECT = SUBJECT_KEYS.map(
-  (key) => import_zod2.z.strictObject({
-    [key]: import_zod2.z.string().min(1),
-    where: import_zod2.z.string().min(1).optional(),
+  (key) => import_zod.z.strictObject({
+    [key]: import_zod.z.string().min(1),
+    where: import_zod.z.string().min(1).optional(),
     ...Object.fromEntries(
       Object.entries(CHECKS).map(([check, schema]) => [
         check,
@@ -338,12 +329,12 @@ var WHEN_CLAUSE_BY_SUBJECT = SUBJECT_KEYS.map(
     }
   )
 );
-var WhenSchema = import_zod2.z.union([
-  import_zod2.z.string().min(1),
-  import_zod2.z.array(import_zod2.z.union([import_zod2.z.string().min(1), ...WHEN_CLAUSE_BY_SUBJECT])).min(1)
+var WhenSchema = import_zod.z.union([
+  import_zod.z.string().min(1),
+  import_zod.z.array(import_zod.z.union([import_zod.z.string().min(1), ...WHEN_CLAUSE_BY_SUBJECT])).min(1)
 ]);
-var BoundaryTransitionSchema = import_zod2.z.strictObject({
-  id: import_zod2.z.string().min(1).describe(
+var BoundaryTransitionSchema = import_zod.z.strictObject({
+  id: import_zod.z.string().min(1).describe(
     "The outcome's name. A PRD scenario links to it as <intent-name>.<id>."
   ),
   when: WhenSchema.describe(
@@ -352,64 +343,155 @@ var BoundaryTransitionSchema = import_zod2.z.strictObject({
   response: emptyIfNull(ResponseOutcomeSchema).describe("This outcome sends an HTTP response.").optional(),
   returns: emptyIfNull(ReturnsOutcomeSchema).describe("This outcome returns a value to its caller.").optional(),
   throws: emptyIfNull(ThrowsOutcomeSchema).describe("This outcome raises an error.").optional(),
-  results: import_zod2.z.array(EffectOutcomeSchema).min(1).describe(
+  exits: import_zod.z.number().int().min(0).max(255).describe("This outcome ends the process with this exit code.").optional(),
+  results: import_zod.z.array(EffectOutcomeSchema).min(1).describe(
     "The effects this outcome has, written in the same verbs suss ask uses: reads, writes, invokes."
   ).optional()
 }).refine((t) => endingsOf(t).length <= 1, {
-  message: "a transition ends one way: give it at most one of response, returns, or throws"
+  message: "a transition ends one way: give it at most one of response, returns, throws, or exits"
 }).refine((t) => endingsOf(t).length === 1 || t.results !== void 0, {
-  message: "each transition must declare an outcome: response, returns, throws, or the effects it results in"
+  message: "each transition must declare an outcome: response, returns, throws, exits, or the effects it results in"
 });
 function endingsOf(t) {
-  return [t.response, t.returns, t.throws].filter((o) => o !== void 0);
+  return [t.response, t.returns, t.throws, t.exits].filter(
+    (o) => o !== void 0
+  );
 }
-var BoundaryIntentSchema = import_zod2.z.strictObject({
-  kind: import_zod2.z.literal("boundary").describe("Makes this document boundary intent for one boundary."),
-  name: import_zod2.z.string().min(1).describe(
+var BoundaryIntentFields = import_zod.z.strictObject({
+  kind: import_zod.z.literal("boundary").describe("Makes this document boundary intent for one boundary."),
+  name: import_zod.z.string().min(1).describe(
     "What this document is called. A PRD scenario links to an outcome of it as <name>.<outcome-id>."
   ),
-  purpose: import_zod2.z.string().min(1).describe("What the boundary is for, in the author's own words."),
-  audience: import_zod2.z.string().min(1).describe("Who calls this boundary and depends on what it does."),
+  purpose: import_zod.z.string().min(1).describe("What the boundary is for, in the author's own words."),
+  audience: import_zod.z.string().min(1).describe("Who calls this boundary and depends on what it does."),
   source: IntentSourceSchema,
   boundary: BoundarySchema.describe(
     "Which boundary in the code the document is about."
   ),
-  transitions: import_zod2.z.array(BoundaryTransitionSchema).min(1).describe("Every outcome the boundary can produce, one entry each.")
+  transitions: import_zod.z.array(BoundaryTransitionSchema).min(1).describe("Every outcome the boundary can produce, one entry each."),
+  always: import_zod.z.array(AlwaysEffectSchema).min(1).describe(
+    "Effects that every transition producing a declared outcome has, apart from the outcomes listed under except."
+  ).optional()
+});
+var BoundaryIntentSchema = BoundaryIntentFields.superRefine((doc, ctx) => {
+  for (const [line, entry] of (doc.always ?? []).entries()) {
+    for (const [at, id] of (entry.except ?? []).entries()) {
+      const problem = exceptProblem(doc.transitions, id);
+      if (problem !== null) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["always", line, "except", at],
+          message: problem
+        });
+      }
+    }
+  }
+  for (const [at, transition] of doc.transitions.entries()) {
+    for (const [line, effect] of (transition.results ?? []).entries()) {
+      for (const column of Object.keys(effect.from ?? {})) {
+        if (!listsColumn(effect, column)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["transitions", at, "results", line, "from", column],
+            message: `from says where ${column} comes from, and the line lists ${column} under neither fields nor by`
+          });
+        }
+      }
+    }
+  }
 });
-var PrdScenarioSchema = import_zod2.z.strictObject({
-  title: import_zod2.z.string().min(1).describe("A short name for the scenario.").optional(),
-  when: import_zod2.z.string().min(1).describe("The condition the scenario covers, in the author's own words."),
-  expect: import_zod2.z.string().min(1).describe("What should happen then, in the author's own words."),
+function listsColumn(effect, column) {
+  return (effect.fields ?? []).includes(column) || oneOrMore(effect.by).includes(column);
+}
+function exceptProblem(transitions, id) {
+  const outcome = transitions.find((t) => t.id === id);
+  if (outcome === void 0) {
+    return `except lists ${id}, and no transition has that id (known: ${transitions.map((t) => t.id).join(", ")})`;
+  }
+  if (endingsOf(outcome).length === 0) {
+    return `except lists ${id}, which states only its effects; an outcome with no response, returns, throws or exits matches every transition, so it cannot be exempted`;
+  }
+  return null;
+}
+var PrdScenarioSchema = import_zod.z.strictObject({
+  title: import_zod.z.string().min(1).describe("A short name for the scenario.").optional(),
+  when: import_zod.z.string().min(1).describe("The condition the scenario covers, in the author's own words."),
+  expect: import_zod.z.string().min(1).describe("What should happen then, in the author's own words."),
   /**
-   * Optional structured link(s) to system-intent outcomes
-   * (`<intent-name>.<outcome-id>`). A scenario without `link` is a
-   * valid pending-link state: fully human-readable, not yet machine-
-   * linked. The link is filled in later by a facilitator (a person, a
-   * platform, or an LLM at authoring time), never required to author.
+   * Links to system-intent outcomes, each written
+   * `<intent-name>.<outcome-id>`. A scenario is backed by a link or by
+   * `coveredBy`, and the checker warns about one with neither. The
+   * schema still accepts it, so a PRD can be written before either
+   * exists.
    *
-   * (The human-readable parts are `when` / `expect`; the field is named
-   * `link`, not `then`, because a data object with a `then` property is
-   * treated as a thenable by Promise resolution, a latent footgun.)
+   * The field is `link` and not `then`, because Promise resolution
+   * treats an object with a `then` property as a thenable.
    */
-  link: import_zod2.z.union([import_zod2.z.string().min(1), import_zod2.z.array(import_zod2.z.string().min(1)).min(1)]).describe(
+  link: ONE_OR_MORE.describe(
     "The boundary-intent outcomes this scenario is about, each written <intent-name>.<outcome-id>."
+  ).optional(),
+  /**
+   * The tests that exercise this scenario, for a promise about which
+   * values come back that no outcome can state. Each is spelled the way
+   * the runner prints it, as `toCoveringTest` reads it.
+   */
+  coveredBy: ONE_OR_MORE.describe(
+    "The tests that exercise this scenario, each written the way its runner prints it: for vitest or RSpec, the test file, then each describe or context title, then the test's own title, joined with ' > '; for pytest, the node id, as in tests/test_orders.py::TestCancel::test_twice."
+  ).optional(),
+  about: ONE_OR_MORE.describe(
+    "What a covering test has to reach for the scenario to count as covered: a boundary or a unit, spelled the way suss ask takes one. Without it, a test has to reach one of the boundaries the PRD's other scenarios link to."
   ).optional()
 });
-var PrdSchema = import_zod2.z.strictObject({
-  kind: import_zod2.z.literal("prd").describe("Makes this document a PRD, a set of scenarios for a feature."),
-  title: import_zod2.z.string().min(1).describe("What this document is called."),
-  purpose: import_zod2.z.string().min(1).describe("What the feature is for, in the author's own words."),
-  audience: import_zod2.z.string().min(1).describe("Who the feature is for."),
+var PrdFields = import_zod.z.strictObject({
+  kind: import_zod.z.literal("prd").describe("Makes this document a PRD, a set of scenarios for a feature."),
+  title: import_zod.z.string().min(1).describe("What this document is called."),
+  purpose: import_zod.z.string().min(1).describe("What the feature is for, in the author's own words."),
+  audience: import_zod.z.string().min(1).describe("Who the feature is for."),
   source: IntentSourceSchema,
-  scenarios: import_zod2.z.array(PrdScenarioSchema).min(1).describe("The situations the feature covers, one entry each.")
+  scenarios: import_zod.z.array(PrdScenarioSchema).min(1).describe("The situations the feature covers, one entry each.")
 });
-var IntentDocSchema = import_zod2.z.discriminatedUnion("kind", [
+var PrdSchema = PrdFields.superRefine((doc, ctx) => {
+  const linksAnything = doc.scenarios.some((s) => s.link !== void 0);
+  for (const [at, scenario] of doc.scenarios.entries()) {
+    const label = scenario.title === void 0 ? `#${at + 1}` : `"${scenario.title}"`;
+    for (const [line, spelled] of oneOrMore(scenario.coveredBy).entries()) {
+      if (toCoveringTest(spelled).titles.length === 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["scenarios", at, "coveredBy", line],
+          message: `scenario ${label} lists the test "${spelled}", which has no title; write the file, then each describe title, then the test's own title, joined with " > ", or for pytest the node id, file::test_name`
+        });
+      }
+    }
+    if (scenario.about !== void 0 && scenario.coveredBy === void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["scenarios", at, "about"],
+        message: `scenario ${label} says what a covering test has to reach, and lists no test under coveredBy`
+      });
+    }
+    if (scenario.coveredBy !== void 0 && scenario.about === void 0 && !linksAnything) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["scenarios", at, "about"],
+        message: `scenario ${label} lists a covering test, and no scenario in this PRD links to an outcome, so there is nothing to check the test reaches; say what it has to reach under about`
+      });
+    }
+  }
+});
+function oneOrMore(written) {
+  if (written === void 0) {
+    return [];
+  }
+  return typeof written === "string" ? [written] : written;
+}
+var IntentDocSchema = import_zod.z.discriminatedUnion("kind", [
   BoundaryIntentSchema,
   PrdSchema
 ]);
 
 // src/summary.ts
-var import_ir_core2 = require("@suss/ir-core");
+var import_ir_core3 = require("@suss/ir-core");
 function intentDocToSummary(doc) {
   if (doc.kind === "prd") {
     return prdToSummary(doc);
@@ -425,7 +507,11 @@ function boundaryIntentToSummary(doc) {
     source: doc.source,
     boundary: toBoundaryBinding(doc.boundary),
     receives: toReceives(doc.boundary),
-    outcomes: doc.transitions.map(toOutcome)
+    outcomes: doc.transitions.map(toOutcome),
+    always: (doc.always ?? []).map((declared) => ({
+      effect: toIntentEffect(declared),
+      except: declared.except ?? []
+    }))
   };
 }
 function prdToSummary(doc) {
@@ -439,18 +525,20 @@ function prdToSummary(doc) {
       title: s.title ?? null,
       when: s.when,
       expect: s.expect,
-      link: s.link === void 0 ? [] : Array.isArray(s.link) ? s.link : [s.link]
+      link: oneOrMore(s.link),
+      coveredBy: oneOrMore(s.coveredBy).map(toCoveringTest),
+      about: oneOrMore(s.about)
     }))
   };
 }
 var BINDINGS = {
-  rest: (boundary) => (0, import_ir_core2.restBinding)({
+  rest: (boundary) => (0, import_ir_core3.restBinding)({
     transport: boundary.transport,
     method: boundary.method,
     path: boundary.path,
     recognition: "intent"
   }),
-  "function-call": (boundary) => (0, import_ir_core2.functionCallBinding)({
+  "function-call": (boundary) => (0, import_ir_core3.functionCallBinding)({
     transport: boundary.transport,
     recognition: "intent",
     ...boundary.module !== void 0 ? { module: boundary.module } : {},
@@ -458,17 +546,17 @@ var BINDINGS = {
     ...boundary.package !== void 0 ? { package: boundary.package } : {},
     ...boundary.exportPath !== void 0 ? { exportPath: boundary.exportPath } : {}
   }),
-  "message-bus": (boundary) => (0, import_ir_core2.messageBusBinding)({
+  "message-bus": (boundary) => (0, import_ir_core3.messageBusBinding)({
     recognition: "intent",
     messageBus: boundary.messageBus,
     channel: boundary.channel
   }),
-  "unit-invocation": (boundary) => (0, import_ir_core2.unitInvocationBinding)({
+  "unit-invocation": (boundary) => (0, import_ir_core3.unitInvocationBinding)({
     recognition: "intent",
     deploymentTarget: boundary.deploymentTarget,
     instanceName: boundary.instanceName
   }),
-  storage: (boundary) => (0, import_ir_core2.storageBinding)({
+  storage: (boundary) => (0, import_ir_core3.storageBinding)({
     recognition: "intent",
     storageSystem: boundary.storageSystem,
     scope: boundary.scope,
@@ -541,24 +629,25 @@ function toReceives(boundary) {
   const read = RECEIVES[boundary.semantics];
   return read(boundary);
 }
-var VERBS = import_ir_core2.EffectRelationSchema.options;
-function toEffect(declared) {
+var VERBS = import_ir_core3.EffectRelationSchema.options;
+function toIntentEffect(declared) {
   const [does, names] = Object.entries(declared).find(
     ([key]) => VERBS.includes(key)
   );
+  const shape = declared.shape === void 0 ? null : bodyToTypeShape(declared.shape);
+  const from = Object.entries(declared.from ?? {}).map(([column, source]) => ({
+    column,
+    path: source.slice(INPUT_SOURCE_PREFIX.length).split(".")
+  }));
   return {
     does,
     names,
     fields: declared.fields ?? [],
-    by: oneOrMore(declared.by)
+    by: oneOrMore(declared.by),
+    ...shape === null ? {} : { shape },
+    ...from.length === 0 ? {} : { from }
   };
 }
-function oneOrMore(written) {
-  if (written === void 0) {
-    return [];
-  }
-  return typeof written === "string" ? [written] : written;
-}
 function subjectOf(clause) {
   for (const does of VERBS) {
     const names = clause[does];
@@ -596,7 +685,7 @@ function whenAsOneLine(when) {
   return typeof when === "string" ? when : toConditions(when).map((condition) => condition.said).join(" and ");
 }
 function toOutcome(t) {
-  const effects = (t.results ?? []).map(toEffect);
+  const effects = (t.results ?? []).map(toIntentEffect);
   const base = {
     id: t.id,
     when: whenAsOneLine(t.when),
@@ -630,9 +719,21 @@ function toOutcome(t) {
       errorType: t.throws.errorType ?? null
     };
   }
+  if (t.exits !== void 0) {
+    return {
+      ...base,
+      kind: "exit",
+      status: t.exits,
+      body: null,
+      errorType: null
+    };
+  }
   return { ...base, kind: "effect", status: null, body: null, errorType: null };
 }
 function bodyToTypeShape(body) {
+  if ("const" in body) {
+    return constantShape(body.const);
+  }
   if (!("type" in body)) {
     if (body.properties === void 0) {
       return null;
@@ -642,6 +743,12 @@ function bodyToTypeShape(body) {
   return shapeToTypeShape(body);
 }
 function shapeToTypeShape(shape) {
+  if ("const" in shape) {
+    return constantShape(shape.const);
+  }
+  if (!("type" in shape)) {
+    return recordShape(shape.properties);
+  }
   if (shape.type === "array") {
     return {
       type: "array",
@@ -653,6 +760,9 @@ function shapeToTypeShape(shape) {
   }
   return PRIMITIVE_TYPE_SHAPES[shape.type];
 }
+function constantShape(value) {
+  return value === null ? { type: "null" } : { type: "literal", value };
+}
 function recordShape(authored) {
   const properties = {};
   for (const [name, prop] of Object.entries(authored)) {
@@ -668,11 +778,224 @@ var PRIMITIVE_TYPE_SHAPES = {
   null: { type: "null" },
   unknown: { type: "unknown" }
 };
+
+// src/changeList.ts
+var VERBS2 = ["adds", "removes", "changes"];
+var OutcomeWordSchema = import_zod2.z.union([
+  import_zod2.z.number().int().min(100).max(599),
+  import_zod2.z.enum(["returns", "throws"]),
+  import_zod2.z.strictObject({ throws: import_zod2.z.string().min(1) })
+]);
+var SubjectSchema = import_zod2.z.union([import_zod2.z.string().min(1), EffectLineSchema]);
+var ENTRY_FIELDS = {
+  adds: SubjectSchema.optional(),
+  removes: SubjectSchema.optional(),
+  changes: SubjectSchema.optional(),
+  outcomes: import_zod2.z.array(OutcomeWordSchema).min(1).describe(
+    "The outcomes the boundary should have: statuses, returns or throws."
+  ).optional(),
+  at: import_zod2.z.string().min(1).describe("The boundary an effect happens at, spelled as suss spells it.").optional()
+};
+function verbsOf(entry) {
+  return VERBS2.filter((verb) => entry[verb] !== void 0);
+}
+function subjectOf2(entry) {
+  const [verb] = verbsOf(entry);
+  return verb === void 0 ? void 0 : entry[verb];
+}
+function withEntryRules(schema) {
+  return schema.refine((entry) => verbsOf(entry).length === 1, {
+    message: "an entry has exactly one of adds, removes or changes"
+  }).refine(
+    (entry) => entry.at === void 0 || typeof subjectOf2(entry) !== "string",
+    {
+      message: "at says which boundary an effect happens at, so it goes with an effect; a boundary entry names its boundary itself"
+    }
+  ).refine(
+    (entry) => entry.outcomes === void 0 || typeof subjectOf2(entry) === "string",
+    {
+      message: "outcomes belong to a boundary; an effect entry says what it touches instead"
+    }
+  );
+}
+var ChangeEntrySchema = withEntryRules(
+  import_zod2.z.strictObject({
+    ...ENTRY_FIELDS,
+    asked: import_zod2.z.string().min(1).describe(
+      "The developer's words that asked for this entry, when they are not the list's."
+    ).optional(),
+    note: import_zod2.z.string().min(1).describe("What the change is, for a subject suss has no words for.").optional()
+  })
+);
+var ExplainedEntrySchema = withEntryRules(
+  import_zod2.z.strictObject({
+    ...ENTRY_FIELDS,
+    why: import_zod2.z.string().min(1).describe("Why the change stays, for the developer to read.")
+  })
+);
+var ChangeListSchema = import_zod2.z.strictObject({
+  asked: import_zod2.z.string().min(1).describe("The developer's request, quoted.").optional(),
+  changes: import_zod2.z.array(ChangeEntrySchema).default([]).describe("Each behavior change the agent intends, one per entry."),
+  explained: import_zod2.z.array(ExplainedEntrySchema).default([]).describe(
+    "Changes nobody asked for that the agent keeps, each with the reason."
+  )
+});
+var WORD_OUTCOMES = {
+  returns: { kind: "return", status: null, errorType: null },
+  throws: { kind: "throw", status: null, errorType: null }
+};
+function toOutcome2(word) {
+  if (typeof word === "number") {
+    return { kind: "response", status: word, errorType: null };
+  }
+  if (typeof word === "string") {
+    return WORD_OUTCOMES[word];
+  }
+  return { kind: "throw", status: null, errorType: word.throws };
+}
+function toSubject(written) {
+  return typeof written === "string" ? { kind: "boundary", names: written } : { kind: "effect", effect: toIntentEffect(written) };
+}
+function commonOf(entry) {
+  const [verb] = verbsOf(entry);
+  return {
+    verb,
+    subject: toSubject(entry[verb]),
+    outcomes: (entry.outcomes ?? []).map(toOutcome2),
+    at: entry.at ?? null
+  };
+}
+function parseChangeList(raw) {
+  const result = ChangeListSchema.safeParse(raw);
+  if (result.success) {
+    return { ok: true, list: changeListToSummary(result.data) };
+  }
+  return {
+    ok: false,
+    problems: result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message
+    }))
+  };
+}
+function changeListToSummary(list) {
+  const asked = list.asked ?? null;
+  return {
+    asked,
+    changes: list.changes.map((entry) => ({
+      ...commonOf(entry),
+      asked: entry.asked ?? asked,
+      note: entry.note ?? null
+    })),
+    explained: list.explained.map((entry) => ({
+      ...commonOf(entry),
+      why: entry.why
+    }))
+  };
+}
+
+// src/findings.ts
+var import_zod3 = require("zod");
+var IntentFindingKindSchema = import_zod3.z.enum([
+  // System intent (kind: boundary) vs code:
+  "uncoveredOutcome",
+  // intent declares an outcome the code never produces
+  "unimplementedBoundary",
+  // intent boundary has no implementing code at all
+  "outcomeShapeMismatch",
+  // a matched outcome whose body shapes disagree
+  "undeclaredOutcome",
+  // code produces a REST status the intent doesn't declare
+  "unkeyableBoundary",
+  // intent boundary can't be keyed, so it can't be checked
+  "renamedBoundary",
+  // a declared store vanished and an undeclared one of the same system appeared with the same outcomes
+  "pathWithoutEffect",
+  // a transition producing a declared outcome lacks an effect the always block says every outcome has
+  "valueFromElsewhere",
+  // a column's value comes from somewhere other than the source a results line gives
+  // What the boundary is handed: the `receives` block against the paths
+  // the unit reads off its input.
+  "unreadInputField",
+  // intent declares a field no transition of the unit reads
+  "undeclaredInputRead",
+  // the unit reads a path the receives block does not list
+  // Outcome intent (kind: prd): whether each scenario's link resolves to
+  // a system-intent outcome.
+  "unlinkedScenario",
+  // scenario has neither a link nor a covering test
+  "danglingScenarioLink",
+  // link names an intent / outcome no boundary intent declares
+  "ambiguousScenarioLink",
+  // link resolves to two or more boundary intents sharing the name
+  // The same question for a scenario backed by a test: whether the test
+  // it lists exists, runs, and reaches what the scenario is about.
+  "missingCoveringTest",
+  // coveredBy lists a test no summary here is
+  "testMissesSubject",
+  // the test never reaches the subject, or reaches it only through a mock
+  "coveringTestSkipped",
+  // the test is marked to be skipped, so it does not run
+  // The same coverage question asked the other way: which declared
+  // behaviour has nobody written a reason for.
+  "undescribedOutcome"
+  // a declared outcome no PRD scenario links to (info)
+]);
+var IntentFindingSeveritySchema = import_zod3.z.enum(["error", "warning", "info"]);
+var IntentRefSchema = import_zod3.z.object({
+  /** The intent doc's `name` (boundary) or `title` (prd). */
+  name: import_zod3.z.string(),
+  /** The declared outcome id, when the finding is outcome-specific. */
+  outcomeId: import_zod3.z.string().optional()
+});
+var IntentFindingSuppressionSchema = import_zod3.z.object({
+  /** The rule's human-written justification. */
+  reason: import_zod3.z.string(),
+  effect: import_zod3.z.enum(["mark", "downgrade", "hide"]),
+  /** Original severity, present only when effect is "downgrade". */
+  originalSeverity: IntentFindingSeveritySchema.optional()
+});
+var IntentFindingSchema = import_zod3.z.object({
+  kind: IntentFindingKindSchema,
+  severity: IntentFindingSeveritySchema,
+  /**
+   * Human-readable boundary label: e.g. `GET /users/:id` or
+   * `fn:@suss/cli::contract`. The key the intent and code were paired on.
+   */
+  boundary: import_zod3.z.string(),
+  /** The intent side of the finding. */
+  intent: IntentRefSchema,
+  /**
+   * The matched code summary as `${file}::${name}`, when the finding
+   * concerns a specific implementation. Absent for unimplementedBoundary.
+   */
+  code: import_zod3.z.string().optional(),
+  /**
+   * Present only on outcome-intent findings. It gives the scenario, by
+   * its optional title, and the qualified outcome ref
+   * (`<intent-name>.<outcome-id>`) that failed to resolve, or the
+   * `coveredBy` entry whose test failed the check. Boundary findings
+   * leave it unset.
+   */
+  scenario: import_zod3.z.object({
+    title: import_zod3.z.string().optional(),
+    link: import_zod3.z.string().optional(),
+    coveredBy: import_zod3.z.string().optional()
+  }).optional(),
+  message: import_zod3.z.string(),
+  /** Present when a .sussignore rule matched this finding. */
+  suppressed: IntentFindingSuppressionSchema.optional()
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCEPTS_NULL,
+  AlwaysEffectSchema,
   BodyShapeSchema,
   BoundarySchema,
+  ChangeListSchema,
+  EffectLineSchema,
+  EffectOutcomeSchema,
+  INPUT_SOURCE_PREFIX,
   IntentDocSchema,
   IntentFindingKindSchema,
   IntentFindingSchema,
@@ -680,9 +1003,15 @@ var PRIMITIVE_TYPE_SHAPES = {
   IntentFindingSuppressionSchema,
   IntentRefSchema,
   IntentSourceSchema,
+  NODE_ID_SEPARATOR,
+  TEST_TITLE_SEPARATOR,
   blanksLeftEmpty,
+  changeListToSummary,
   fillBlanks,
   intentDocToSummary,
+  parseChangeList,
   toBoundaryBinding,
+  toCoveringTest,
+  toIntentEffect,
   toReceives
 });