@alex.botez/elaborate 1.0.0

package/dist/phases/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/phases/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,uDAAuD;AACvD,eAAO,MAAM,YAAY;;;;;;EAEvB,CAAC;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,8DAA8D;AAC9D,eAAO,MAAM,UAAU,iDAA+C,CAAC;AACvE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD,gDAAgD;AAChD,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAItD,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,wBAAwB;AACxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,mDAAmD;AACnD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;EAI3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,uBAAuB;AACvB,eAAO,MAAM,eAAe,iDAA+C,CAAC;AAC5E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB,sDAAoD,CAAC;AACnF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,uDAAuD;AACvD,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,iBAAiB,EAAE,MAAM,CAIpE,CAAC;AAEF,wCAAwC;AACxC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;EAIxB,CAAC;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,WAAW;AACX,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQrB,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE9C,kBAAkB;AAClB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,0CAA0C;AAC1C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;EAI1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,2CAA2C;AAC3C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;EAI5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,yFAAyF;AACzF,eAAO,MAAM,gBAAgB,oDAAkD,CAAC;AAChF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,sDAAsD;AACtD,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAIlE,CAAC;AAEF,eAAO,MAAM,cAAc,wCAAsC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,kEAAkE;AAClE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,wBAAwB;AACxB,eAAO,MAAM,iBAAiB;;;;;;;;;EAG5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,iEAAiE;AACjE,eAAO,MAAM,aAAa;;;;;;;;;;;;EAIxB,CAAC;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,gFAAgF;AAChF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAI7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,yCAAyC;AACzC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,uCAAuC;AACvC,wBAAgB,oBAAoB,IAAI,SAAS,CAahD"}

package/dist/phases/schema.js

@@ -0,0 +1,157 @@
+/**
+ * MVP artifact schema using Zod
+ */
+import { z } from "zod";
+/** Provenance — which prompt surfaced this artifact */
+export const SourceSchema = z.object({
+    promptId: z.string(),
+});
+/** Goal status progression: fuzzy → elaborated → confirmed */
+export const GoalStatus = z.enum(["fuzzy", "elaborated", "confirmed"]);
+/** Deterministic confidence from goal status */
+export const GOAL_CONFIDENCE = {
+    fuzzy: 0.5,
+    elaborated: 0.7,
+    confirmed: 0.9,
+};
+/** In-scope item — no status progression, boundary decisions are binary */
+export const InScopeItemSchema = z.object({
+    id: z.string(),
+    description: z.string().min(1),
+    relatedGoals: z.array(z.string()).default([]),
+    confidence: z.number().min(0).max(1),
+    source: SourceSchema.optional(),
+});
+/** Out-of-scope item */
+export const OutOfScopeItemSchema = z.object({
+    id: z.string(),
+    description: z.string().min(1),
+    reason: z.string().default(""),
+    relatedGoals: z.array(z.string()).default([]),
+    confidence: z.number().min(0).max(1),
+    source: SourceSchema.optional(),
+});
+/** Constraint — external non-negotiable reality */
+export const ConstraintSchema = z.object({
+    id: z.string(),
+    description: z.string().min(1),
+    source: SourceSchema.optional(),
+});
+/** Stakeholder type */
+export const StakeholderType = z.enum(["primary", "secondary", "external"]);
+/** Stakeholder status progression: identified → elaborated → confirmed */
+export const StakeholderStatus = z.enum(["identified", "elaborated", "confirmed"]);
+/** Deterministic confidence from stakeholder status */
+export const STAKEHOLDER_CONFIDENCE = {
+    identified: 0.5,
+    elaborated: 0.7,
+    confirmed: 0.9,
+};
+/** Purpose statement with confidence */
+export const PurposeSchema = z.object({
+    statement: z.string().min(1),
+    confidence: z.number().min(0).max(1),
+    source: SourceSchema.optional(),
+});
+/** Goal */
+export const GoalSchema = z.object({
+    id: z.string(),
+    title: z.string().min(1),
+    description: z.string(),
+    rationale: z.string().optional(),
+    status: GoalStatus,
+    confidence: z.number().min(0).max(1),
+    source: SourceSchema.optional(),
+});
+/** Stakeholder */
+export const StakeholderSchema = z.object({
+    id: z.string(),
+    name: z.string().min(1),
+    type: StakeholderType,
+    role: z.string().default(""),
+    concerns: z.array(z.string()).default([]),
+    isRespondent: z.boolean().default(false),
+    status: StakeholderStatus.default("identified"),
+    confidence: z.number().min(0).max(1).default(0.5),
+    source: SourceSchema.optional(),
+});
+/** Advantage statement with confidence */
+export const AdvantageSchema = z.object({
+    statement: z.string().min(1),
+    confidence: z.number().min(0).max(1),
+    source: SourceSchema.optional(),
+});
+/** Measurement criteria with confidence */
+export const MeasurementSchema = z.object({
+    statement: z.string().min(1),
+    confidence: z.number().min(0).max(1),
+    source: SourceSchema.optional(),
+});
+/** Assumption status: no progression — binary validation with explicit "can't verify" */
+export const AssumptionStatus = z.enum(["unvalidated", "validated", "flagged"]);
+/** Deterministic confidence from assumption status */
+export const ASSUMPTION_CONFIDENCE = {
+    unvalidated: 0.5,
+    validated: 0.9,
+    flagged: 0.7,
+};
+export const AssumptionType = z.enum(["hypothesis", "invariant"]);
+/** Assumption — believed-but-unverified domain property (KAOS) */
+export const AssumptionSchema = z.object({
+    id: z.string(),
+    statement: z.string().min(1),
+    type: AssumptionType,
+    status: AssumptionStatus.default("unvalidated"),
+    relatedGoals: z.array(z.string()).default([]),
+    confidence: z.number().min(0).max(1),
+    source: SourceSchema.optional(),
+});
+/** Waiting room item */
+export const WaitingItemSchema = z.object({
+    id: z.string(),
+    content: z.string().min(1),
+});
+/** A finding — gap or observation captured during the session */
+export const FindingSchema = z.object({
+    id: z.string(),
+    content: z.string().min(1),
+    phase: z.string(),
+});
+/** Residual item — WR content that survived classify-and-route in validation */
+export const ResidualItemSchema = z.object({
+    id: z.string(),
+    content: z.string().min(1),
+    reason: z.string().min(1),
+});
+/** Complete artifacts structure (MVP) */
+export const ArtifactsSchema = z.object({
+    purpose: PurposeSchema.optional(),
+    advantage: AdvantageSchema.optional(),
+    measurement: MeasurementSchema.optional(),
+    goals: z.array(GoalSchema).default([]),
+    stakeholders: z.array(StakeholderSchema).default([]),
+    inScope: z.array(InScopeItemSchema).default([]),
+    outOfScope: z.array(OutOfScopeItemSchema).default([]),
+    constraints: z.array(ConstraintSchema).default([]),
+    assumptions: z.array(AssumptionSchema).default([]),
+    domainHints: z.array(z.string()).default([]),
+    waitingRoom: z.array(WaitingItemSchema).default([]),
+    findings: z.array(FindingSchema).default([]),
+    residual: z.array(ResidualItemSchema).default([]),
+});
+/** Create empty artifacts structure */
+export function createEmptyArtifacts() {
+    return {
+        goals: [],
+        stakeholders: [],
+        inScope: [],
+        outOfScope: [],
+        constraints: [],
+        assumptions: [],
+        domainHints: [],
+        waitingRoom: [],
+        findings: [],
+        residual: [],
+    };
+}
+//# sourceMappingURL=schema.js.map

package/dist/phases/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/phases/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,uDAAuD;AACvD,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;CACrB,CAAC,CAAC;AAGH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC;AAGvE,gDAAgD;AAChD,MAAM,CAAC,MAAM,eAAe,GAA+B;IACzD,KAAK,EAAE,GAAG;IACV,UAAU,EAAE,GAAG;IACf,SAAS,EAAE,GAAG;CACf,CAAC;AAEF,2EAA2E;AAC3E,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IAC7C,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC;AAGH,wBAAwB;AACxB,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IAC9B,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IAC7C,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC;AAGH,mDAAmD;AACnD,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC;AAGH,uBAAuB;AACvB,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC;AAG5E,0EAA0E;AAC1E,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC;AAGnF,uDAAuD;AACvD,MAAM,CAAC,MAAM,sBAAsB,GAAsC;IACvE,UAAU,EAAE,GAAG;IACf,UAAU,EAAE,GAAG;IACf,SAAS,EAAE,GAAG;CACf,CAAC;AAEF,wCAAwC;AACxC,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC;AAGH,WAAW;AACX,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACxB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,MAAM,EAAE,UAAU;IAClB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC;AAGH,kBAAkB;AAClB,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,IAAI,EAAE,eAAe;IACrB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IAC5B,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IACzC,YAAY,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;IACxC,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,YAAY,CAAC;IAC/C,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC;IACjD,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC;AAGH,0CAA0C;AAC1C,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC;AAGH,2CAA2C;AAC3C,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC;AAGH,yFAAyF;AACzF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC,CAAC;AAGhF,sDAAsD;AACtD,MAAM,CAAC,MAAM,qBAAqB,GAAqC;IACrE,WAAW,EAAE,GAAG;IAChB,SAAS,EAAE,GAAG;IACd,OAAO,EAAE,GAAG;CACb,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC;AAGlE,kEAAkE;AAClE,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5B,IAAI,EAAE,cAAc;IACpB,MAAM,EAAE,gBAAgB,CAAC,OAAO,CAAC,aAAa,CAAC;IAC/C,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IAC7C,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC;AAGH,wBAAwB;AACxB,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC3B,CAAC,CAAC;AAGH,iEAAiE;AACjE,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;CAClB,CAAC,CAAC;AAGH,gFAAgF;AAChF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC1B,CAAC,CAAC;AAGH,yCAAyC;AACzC,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,OAAO,EAAE,aAAa,CAAC,QAAQ,EAAE;IACjC,SAAS,EAAE,eAAe,CAAC,QAAQ,EAAE;IACrC,WAAW,EAAE,iBAAiB,CAAC,QAAQ,EAAE;IACzC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IACtC,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IACpD,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IAC/C,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IACrD,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IAClD,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IAClD,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IAC5C,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IACnD,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IAC5C,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;CAClD,CAAC,CAAC;AAGH,uCAAuC;AACvC,MAAM,UAAU,oBAAoB;IAClC,OAAO;QACL,KAAK,EAAE,EAAE;QACT,YAAY,EAAE,EAAE;QAChB,OAAO,EAAE,EAAE;QACX,UAAU,EAAE,EAAE;QACd,WAAW,EAAE,EAAE;QACf,WAAW,EAAE,EAAE;QACf,WAAW,EAAE,EAAE;QACf,WAAW,EAAE,EAAE;QACf,QAAQ,EAAE,EAAE;QACZ,QAAQ,EAAE,EAAE;KACb,CAAC;AACJ,CAAC"}

package/dist/phases/scope.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Scope definition phase — boundary classification via contrast questioning.
+ *
+ * Captures scope through:
+ * 1. Seed extraction + waiting room drain
+ * 2. Constraint discovery
+ * 3. Contrast questions for ambiguous items (in/out/deferred)
+ * 4. Contradiction check (scope vs goals alignment)
+ * 5. Quality check (nudge if empty)
+ * 6. Confirmation with revision loop
+ *
+ * Novel schema — no RE framework defines scope items for structured dialog.
+ * No status progression: boundary decisions are binary. Confidence without status.
+ */
+import type { WorkflowContext } from "../durable/index.js";
+import type { ArtifactAggregate } from "./aggregate/index.js";
+export declare function runScope(ctx: WorkflowContext, agg: ArtifactAggregate): Promise<void>;
+//# sourceMappingURL=scope.d.ts.map

package/dist/phases/scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../src/phases/scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AA+Q9D,wBAAsB,QAAQ,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuN1F"}

package/dist/phases/scope.js

@@ -0,0 +1,440 @@
+/**
+ * Scope definition phase — boundary classification via contrast questioning.
+ *
+ * Captures scope through:
+ * 1. Seed extraction + waiting room drain
+ * 2. Constraint discovery
+ * 3. Contrast questions for ambiguous items (in/out/deferred)
+ * 4. Contradiction check (scope vs goals alignment)
+ * 5. Quality check (nudge if empty)
+ * 6. Confirmation with revision loop
+ *
+ * Novel schema — no RE framework defines scope items for structured dialog.
+ * No status progression: boundary decisions are binary. Confidence without status.
+ */
+import { z } from "zod";
+import { inferStep, inferCompositionStep } from "../interview/index.js";
+import { buildFullContext, confirmationCloser, confirmPhase } from "./shared.js";
+import { SCOPE_CONTRAST_CAP } from "./configuration.js";
+const SeedExtractionSchema = z.object({
+    inScope: z.array(z.object({
+        description: z.string().describe("what is in scope"),
+        relatedGoals: z.array(z.string()).optional().describe("goal IDs this supports"),
+    })).optional().describe("items clearly in scope from the conversation, empty if none"),
+    outOfScope: z.array(z.object({
+        description: z.string().describe("what is excluded"),
+        reason: z.string().optional().describe("why it's excluded"),
+        relatedGoals: z.array(z.string()).optional().describe("goal IDs this relates to"),
+    })).optional().describe("items clearly excluded, empty if none"),
+    ambiguous: z.array(z.object({
+        description: z.string().describe("the ambiguous item"),
+        relatedGoals: z.array(z.string()).optional().describe("goal IDs this relates to"),
+    })).optional().describe("items mentioned but unclear if in or out, empty if none"),
+    drainedWaitingRoomIds: z.array(z.string()).optional()
+        .describe('IDs of waiting room items classified into scope (e.g. ["waiting_001"]), empty if none'),
+});
+const ScopeSeedResponseSchema = z.object({
+    responseInterpretation: z.string().describe("what the respondent meant"),
+    confirmedInScope: z.array(z.string()).optional().describe("IDs the user confirmed as in-scope (or all if confirmed)"),
+    confirmedOutOfScope: z.array(z.string()).optional().describe("IDs the user confirmed as out-of-scope"),
+    removedIds: z.array(z.string()).optional().describe("IDs to remove entirely"),
+    newItems: z.array(z.object({ description: z.string().describe("the scope item"), classification: z.string().optional().describe("'in', 'out', or 'ambiguous'") })).optional().describe("new items mentioned, empty if none"),
+    waitingRoomItems: z.array(z.object({ content: z.string().describe("the item text") })).optional().describe("items that sound like assumptions rather than scope, empty if none"),
+});
+const ConstraintExtractionSchema = z.object({
+    responseInterpretation: z.string().describe("what the respondent meant, resolving any suggestion references"),
+    constraints: z.array(z.object({ description: z.string().describe("the constraint") })).optional().describe("constraints extracted from the response, empty if none"),
+    waitingRoomItems: z.array(z.object({ content: z.string().describe("the item text") })).optional().describe("items that sound like assumptions rather than constraints, empty if none"),
+});
+const ContrastExtractionSchema = z.object({
+    responseInterpretation: z.string().describe("what the respondent meant, resolving any suggestion references"),
+    classification: z.enum(["in", "out", "deferred"]).optional().describe("where this item belongs"),
+    reason: z.string().optional().describe("why it's excluded (only if classification is 'out'), empty otherwise"),
+    relatedGoals: z.array(z.string()).optional().describe("goal IDs this item relates to, empty if none"),
+    waitingRoomItems: z.array(z.object({ content: z.string().describe("the item text") })).optional().describe("items that sound like assumptions, empty if none"),
+});
+const AmbiguousSortSchema = z.object({
+    rankedAmbiguousIds: z.array(z.string()).describe("ambiguous item indices (as strings) ordered from highest to lowest priority for contrast questions"),
+    autoClassifications: z.array(z.object({
+        index: z.string().describe("the ambiguous item index (as string)"),
+        classification: z.enum(["in", "out"]).describe("best-guess classification"),
+        relatedGoals: z.array(z.string()).optional().describe("goal IDs this item relates to"),
+        reason: z.string().optional().describe("why classified out (only if 'out')"),
+    })).describe("default in/out classification for items that won't get contrast questions"),
+});
+function ambiguousSort(ambiguousItems, artifacts) {
+    const itemRef = ambiguousItems.map((item, i) => {
+        const goals = item.relatedGoals?.length ? ` (goals: ${item.relatedGoals.join(", ")})` : "";
+        return `[${i}] "${item.description}"${goals}`;
+    }).join("; ");
+    const goalRef = artifacts.goals.map((g) => `[${g.id}] "${g.title}" — ${g.description}`).join("; ");
+    const scopeRef = [
+        ...artifacts.inScope.map((s) => `IN: "${s.description}"`),
+        ...artifacts.outOfScope.map((s) => `OUT: "${s.description}"`),
+    ].join("; ");
+    return inferStep({
+        id: "scope-ambiguous-sort",
+        schema: AmbiguousSortSchema,
+        message: `
+      Rank these ambiguous scope items by priority for boundary clarification, and provide default in/out classifications for lower-priority items.
+
+      Ambiguous items: ${itemRef}
+      Goals: ${goalRef}
+      Existing scope: ${scopeRef}
+
+      Ranking criteria (in order):
+      1. Connected to more goals: items touching multiple goals affect more downstream requirements.
+      2. Higher ambiguity: items where the in/out decision is genuinely unclear rank above items that are almost certainly one way.
+
+      Return ALL indices in rankedAmbiguousIds (highest priority first).
+      For items beyond the top ${SCOPE_CONTRAST_CAP}, provide autoClassifications with your best-guess in/out.
+    `,
+    });
+}
+const ContradictionCheckSchema = z.object({
+    contradictions: z.array(z.object({
+        description: z.string().describe("what the contradiction is"),
+        scopeItemId: z.string().describe("the scope item ID"),
+        goalId: z.string().describe("the conflicting goal ID"),
+    })).optional().describe("scope items that make a confirmed/elaborated goal infeasible — the goal CANNOT be achieved without this item. NOT: soft tensions where a goal is merely weakened, less efficient, or harder to achieve. Empty array if none"),
+    orphans: z.array(z.object({
+        scopeItemId: z.string().describe("the scope item ID"),
+        description: z.string().describe("what the orphan item is"),
+    })).optional().describe("in-scope items with no goal connection"),
+});
+const ScopeDedupSchema = z.object({
+    duplicateGroups: z.array(z.object({
+        keepId: z.string().describe("the scope item ID to keep"),
+        removeIds: z.array(z.string()).describe("scope item IDs that are semantically duplicate of keepId"),
+    })).describe("groups of semantically duplicate scope items — only flag items you are CERTAIN describe the same thing with different wording"),
+});
+const ScopeRevisionSchema = z.object({
+    responseInterpretation: z.string().describe("what the respondent meant, resolving any suggestion references"),
+    inScope: z.array(z.object({ description: z.string().describe("what is in scope"), relatedGoals: z.array(z.string()).optional().describe("goal IDs this supports") })).optional().describe("new or updated in-scope items, empty if none"),
+    outOfScope: z.array(z.object({ description: z.string().describe("what is excluded"), reason: z.string().optional().describe("why it's excluded"), relatedGoals: z.array(z.string()).optional().describe("goal IDs this relates to") })).optional().describe("new or updated out-of-scope items, empty if none"),
+    removedIds: z.array(z.string()).optional().describe("scope item IDs to remove, empty if none"),
+    reclassifiedItems: z.array(z.object({
+        id: z.string().describe("scope item ID to reclassify"),
+        newClassification: z.enum(["in", "out"]).describe("new classification"),
+    })).optional().describe("existing scope items to move between in-scope and out-of-scope, empty if none"),
+    waitingRoomItems: z.array(z.object({ content: z.string().describe("the item text") })).optional().describe("items that sound like assumptions, empty if none"),
+});
+function seedPresent(artifacts, ambiguousDescriptions) {
+    const letters = "abcdefghijklmnopqrstuvwxyz";
+    const inStart = 0;
+    const outStart = artifacts.inScope.length;
+    const ambStart = outStart + artifacts.outOfScope.length;
+    const total = ambStart + ambiguousDescriptions.length;
+    if (total === 0) {
+        return {
+            id: "scope-seed-present",
+            message: `I haven't identified specific **scope boundaries** from our conversation yet.\n\nWhat are the main things your project will definitely include or exclude?`,
+        };
+    }
+    const inSection = artifacts.inScope.length > 0
+        ? `**In scope:**\n${artifacts.inScope.map((item, i) => `${letters[inStart + i]}) ${item.description}`).join("\n")}\n\n`
+        : "";
+    const outSection = artifacts.outOfScope.length > 0
+        ? `**Out of scope:**\n${artifacts.outOfScope.map((item, i) => {
+            const reason = item.reason ? ` — ${item.reason}` : "";
+            return `${letters[outStart + i]}) ${item.description}${reason}`;
+        }).join("\n")}\n\n`
+        : "";
+    const ambSection = ambiguousDescriptions.length > 0
+        ? `**Unclear (we'll sort these out):**\n${ambiguousDescriptions.map((desc, i) => `${letters[ambStart + i]}) ${desc}`).join("\n")}\n\n`
+        : "";
+    return {
+        id: "scope-seed-present",
+        message: `
+      Based on our conversation, here's what I see for your project scope:
+      ${inSection}${outSection}${ambSection}
+      Does this look right? You can confirm, add items, remove items, or reclassify.
+    `,
+    };
+}
+function constraintComposition(artifacts) {
+    return inferCompositionStep({
+        id: "",
+        fallback: "Are there any constraints your project must work within? Think about technical limits, budget, timeline, or regulations.",
+        message: `
+      Compose a question about project constraints — non-negotiable realities the project must work within.
+      Ask about technical, budget, timeline, regulatory, or organizational constraints.
+      Include 2-3 suggested constraints relevant to the project domain.
+
+      Context:
+      ${buildFullContext(artifacts)}
+    `,
+    });
+}
+function contrastComposition(description, artifacts) {
+    return inferCompositionStep({
+        id: "",
+        fallback: `Is "${description}" in scope or out of scope for this project?`,
+        message: `
+      Compose a contrast question about: "${description}"
+      Ask whether this item is in scope or out of scope for the project.
+      Frame it as a clear choice. Include 2-3 suggested answers that clarify the boundary.
+
+      Context:
+      ${buildFullContext(artifacts)}
+    `,
+    });
+}
+function nudge() {
+    return {
+        id: "scope-nudge",
+        message: `
+      We haven't defined any scope boundaries yet.
+      Could you tell me at least one thing that's definitely part of this project, or one thing that's explicitly NOT part of it?`,
+    };
+}
+function contradictionCheck(artifacts) {
+    const goalRef = artifacts.goals.map((g) => `[${g.id}] "${g.title}" (${g.status})`).join("; ");
+    const scopeRef = [
+        ...artifacts.inScope.map((s) => `IN [${s.id}]: "${s.description}" (goals: ${s.relatedGoals.join(", ") || "none"})`),
+        ...artifacts.outOfScope.map((s) => `OUT [${s.id}]: "${s.description}" (goals: ${s.relatedGoals.join(", ") || "none"})`),
+        ...artifacts.constraints.map((c) => `CONSTRAINT [${c.id}]: "${c.description}"`),
+    ].join("; ");
+    return inferStep({
+        id: "scope-contradiction-check",
+        message: `
+      Check for contradictions between scope decisions and goals.
+
+      Goals: ${goalRef}
+      Scope: ${scopeRef}
+
+      Find:
+      1. Out-of-scope items needed by a confirmed/elaborated goal → contradiction
+      2. Constraints that make a goal infeasible → contradiction
+      3. In-scope items with no connection to any goal → orphan (not contradiction, just a note)
+    `,
+        schema: ContradictionCheckSchema,
+    });
+}
+function scopeDedup(artifacts, suffix) {
+    const allItems = [
+        ...artifacts.inScope.map((s) => `IN [${s.id}]: "${s.description}"`),
+        ...artifacts.outOfScope.map((s) => `OUT [${s.id}]: "${s.description}"`),
+    ].join("; ");
+    return inferStep({
+        id: suffix ? `scope-dedup-${suffix}` : "scope-dedup",
+        schema: ScopeDedupSchema,
+        message: `
+      Identify semantically duplicate scope items — items that describe the same concept with different wording.
+
+      Scope items: ${allItems}
+
+      Rules:
+      1. Only group items you are CERTAIN are duplicates (same concept, different words). Related but distinct items are NOT duplicates.
+      2. For each group, pick the clearest/most specific description as keepId.
+      3. Items in different classifications (IN vs OUT) are never duplicates — they represent a conflict, not a duplicate.
+      4. Return an empty array if there are no duplicates.
+    `,
+    });
+}
+function confirmation(artifacts, findings) {
+    const inSection = artifacts.inScope.length > 0
+        ? `**In scope:**\n${artifacts.inScope.map((s) => {
+            const goals = s.relatedGoals.length > 0 ? ` (supports: ${s.relatedGoals.join(", ")})` : "";
+            return `- ${s.description}${goals}`;
+        }).join("\n")}\n\n`
+        : "";
+    const outSection = artifacts.outOfScope.length > 0
+        ? `**Out of scope:**\n${artifacts.outOfScope.map((s) => {
+            const reason = s.reason ? ` — ${s.reason}` : "";
+            return `- ${s.description}${reason}`;
+        }).join("\n")}\n\n`
+        : "";
+    const constSection = artifacts.constraints.length > 0
+        ? `**Constraints:**\n${artifacts.constraints.map((c) => `- ${c.description}`).join("\n")}\n\n`
+        : "";
+    const scopeFindings = findings.filter((f) => f.phase === "scope");
+    const findingsSection = scopeFindings.length > 0
+        ? `**Notes:**\n${scopeFindings.map((f) => `- ${f.content}`).join("\n")}\n\n`
+        : "";
+    return {
+        id: "scope-confirmation",
+        message: `
+      Here's what I've captured for your project scope:
+      ${inSection}${outSection}${constSection}${findingsSection}
+      ${confirmationCloser()}`,
+    };
+}
+export async function runScope(ctx, agg) {
+    const artifacts = agg.data;
+    // Track waiting room IDs before seeding so we only drain pre-existing items
+    const preWaitingRoomIds = new Set(artifacts.waitingRoom.map((w) => w.id));
+    // Step 1: Seed extraction + waiting room drain
+    const seeds = await ctx.seed({
+        id: "scope-seed-extraction",
+        artifactsContext: buildFullContext(artifacts, { includeWaitingRoom: true }),
+        schema: SeedExtractionSchema,
+        guidance: "Extract scope candidates. Classify each as clearly in-scope, out-of-scope, or ambiguous. Link to goal IDs. Pull hints from the waitingRoom items in the context; return drainedWaitingRoomIds for the items you consumed.",
+    });
+    const ambiguousItems = seeds.ambiguous ?? [];
+    const src = ctx.currentSource;
+    agg.addInScopeItems(seeds.inScope ?? [], undefined, src);
+    agg.addOutOfScopeItems(seeds.outOfScope ?? [], undefined, src);
+    // Drain waiting room items the LLM reported as consumed (by ID)
+    const drainedIds = new Set((seeds.drainedWaitingRoomIds ?? []).filter((id) => preWaitingRoomIds.has(id)));
+    agg.drainWaitingRoom(drainedIds);
+    // Present seed list
+    const ambiguousDescriptions = ambiguousItems.map((a) => a.description);
+    // Classify seed response
+    const allItems = [...artifacts.inScope, ...artifacts.outOfScope];
+    const itemRef = allItems.map((s) => `${s.id}: "${s.description}"`).join(", ");
+    const seedClass = await ctx.promptReview(seedPresent(artifacts, ambiguousDescriptions), "scope-seed-classification", itemRef, buildFullContext(artifacts), ScopeSeedResponseSchema, { defaults: { responseInterpretation: "", confirmedInScope: [], confirmedOutOfScope: [], removedIds: [], newItems: [], waitingRoomItems: [] } });
+    // Remove rejected items
+    const removedIds = new Set(seedClass.removedIds ?? []);
+    if (removedIds.size > 0) {
+        agg.removeScopeItems(removedIds);
+    }
+    // Add new items from response
+    const reviewSrc = ctx.currentSource;
+    for (const item of seedClass.newItems ?? []) {
+        if (item.classification === "out") {
+            agg.addOutOfScopeItems([item], undefined, reviewSrc);
+        }
+        else {
+            agg.addInScopeItems([item], undefined, reviewSrc);
+        }
+    }
+    agg.addWaitingRoomItems(seedClass.waitingRoomItems ?? []);
+    // Step 2: Constraints (with deviation resilience)
+    const constExtraction = await ctx.composePromptExtract("scope-constraint", () => constraintComposition(artifacts), { artifactsContext: buildFullContext(artifacts), schema: ConstraintExtractionSchema, guidance: "Constraints are non-negotiable external realities (technical limits, budget, timeline, regulations)." }, { park: (items) => agg.addWaitingRoomItems(items), maxRetries: 2, defaults: { responseInterpretation: "", constraints: [], waitingRoomItems: [] } });
+    agg.addConstraints(constExtraction.constraints ?? [], ctx.currentSource);
+    agg.addWaitingRoomItems(constExtraction.waitingRoomItems ?? []);
+    // Steps 3-4: Sort + cap ambiguous items, then contrast questions for top items
+    let contrastItems;
+    if (ambiguousItems.length > SCOPE_CONTRAST_CAP) {
+        const sortResult = await ctx.infer(ambiguousSort(ambiguousItems, artifacts));
+        const validIndices = new Set(ambiguousItems.map((_, i) => String(i)));
+        const ranked = sortResult.rankedAmbiguousIds.filter((id) => validIndices.has(id));
+        const keepIndices = ranked.length >= SCOPE_CONTRAST_CAP
+            ? ranked.slice(0, SCOPE_CONTRAST_CAP)
+            : ambiguousItems.slice(0, SCOPE_CONTRAST_CAP).map((_, i) => String(i));
+        const keepSet = new Set(keepIndices);
+        contrastItems = keepIndices.map((idx) => ambiguousItems[Number(idx)]);
+        // Auto-classify excess items
+        const autoMap = new Map(sortResult.autoClassifications.map((ac) => [ac.index, ac]));
+        for (let i = 0; i < ambiguousItems.length; i++) {
+            if (keepSet.has(String(i)))
+                continue;
+            const auto = autoMap.get(String(i));
+            const item = ambiguousItems[i];
+            if (auto?.classification === "out") {
+                agg.addOutOfScopeItems([{ description: item.description, reason: auto.reason, relatedGoals: auto.relatedGoals }], undefined, src);
+            }
+            else {
+                agg.addInScopeItems([{ description: item.description, relatedGoals: auto?.relatedGoals ?? item.relatedGoals }], undefined, src);
+            }
+        }
+    }
+    else {
+        contrastItems = ambiguousItems;
+    }
+    for (let i = 0; i < contrastItems.length; i++) {
+        const item = contrastItems[i];
+        const contrastResult = await ctx.composePromptExtract(`scope-contrast-${i}`, () => contrastComposition(item.description, artifacts), { artifactsContext: buildFullContext(artifacts), schema: ContrastExtractionSchema, focus: `"${item.description}"` }, { defaults: { responseInterpretation: "", classification: "deferred", reason: "", relatedGoals: [], waitingRoomItems: [] } });
+        const contrastSrc = ctx.currentSource;
+        const resolvedDescription = contrastResult.responseInterpretation || item.description;
+        if (contrastResult.classification === "in") {
+            agg.addInScopeItems([{
+                    description: resolvedDescription,
+                    relatedGoals: contrastResult.relatedGoals,
+                }], undefined, contrastSrc);
+        }
+        else if (contrastResult.classification === "out") {
+            agg.addOutOfScopeItems([{
+                    description: resolvedDescription,
+                    reason: contrastResult.reason,
+                    relatedGoals: contrastResult.relatedGoals,
+                }], undefined, contrastSrc);
+        }
+        else {
+            agg.addWaitingRoomItems([{ content: item.description }]);
+        }
+        agg.addWaitingRoomItems(contrastResult.waitingRoomItems ?? []);
+    }
+    // Step 5: Contradiction check
+    if (artifacts.goals.length > 0 && (artifacts.inScope.length > 0 || artifacts.outOfScope.length > 0)) {
+        const checkResult = await ctx.infer(contradictionCheck(artifacts));
+        // Surface contradictions
+        if (checkResult.contradictions && checkResult.contradictions.length > 0) {
+            const contradictionDescs = checkResult.contradictions.map((c) => c.description);
+            await ctx.promptReextract("scope-contradiction-clarification", contradictionDescs, buildFullContext(artifacts), z.object({}), { defaults: {} });
+        }
+        // Record orphans as findings
+        if (checkResult.orphans && checkResult.orphans.length > 0) {
+            for (const orphan of checkResult.orphans) {
+                agg.addFinding(`In-scope item "${orphan.description}" has no connection to any stated goal`, "scope");
+            }
+        }
+    }
+    // Step 6: Quality check
+    if (artifacts.inScope.length === 0 && artifacts.outOfScope.length === 0) {
+        // One nudge
+        const nudgeClass = await ctx.promptExtract(nudge(), { artifactsContext: buildFullContext(artifacts), schema: SeedExtractionSchema }, { defaults: { inScope: [], outOfScope: [], ambiguous: [], drainedWaitingRoomIds: [] } });
+        const nudgeSrc = ctx.currentSource;
+        agg.addInScopeItems(nudgeClass.inScope ?? [], undefined, nudgeSrc);
+        agg.addOutOfScopeItems(nudgeClass.outOfScope ?? [], undefined, nudgeSrc);
+        // If still empty after nudge, finding
+        if (artifacts.inScope.length === 0 && artifacts.outOfScope.length === 0) {
+            agg.addFinding("No scope boundaries defined — downstream requirements may lack focus", "scope");
+        }
+    }
+    // Step 6b: Semantic deduplication
+    if (artifacts.inScope.length + artifacts.outOfScope.length >= 2) {
+        const dedupResult = await ctx.infer(scopeDedup(artifacts));
+        for (const group of dedupResult.duplicateGroups) {
+            const validRemoveIds = group.removeIds.filter((id) => artifacts.inScope.some((s) => s.id === id) || artifacts.outOfScope.some((s) => s.id === id));
+            if (validRemoveIds.length > 0) {
+                agg.removeScopeItems(new Set(validRemoveIds));
+            }
+        }
+    }
+    // Step 7: Single-pass confirmation
+    const { response, approved } = await confirmPhase(ctx, confirmation(artifacts, artifacts.findings), artifacts, "scope", 0);
+    if (!approved) {
+        const extraction = await ctx.extract({
+            id: "scope-revision",
+            response,
+            artifactsContext: buildFullContext(artifacts),
+            schema: ScopeRevisionSchema,
+        });
+        // Reclassify items first (before adds, so exact-match guard doesn't block re-adds)
+        for (const item of extraction.reclassifiedItems ?? []) {
+            const existing = artifacts.inScope.find((s) => s.id === item.id)
+                ?? artifacts.outOfScope.find((s) => s.id === item.id);
+            if (!existing)
+                continue;
+            agg.removeScopeItems(new Set([item.id]));
+            if (item.newClassification === "in") {
+                agg.addInScopeItems([{ description: existing.description, relatedGoals: existing.relatedGoals }], undefined, existing.source);
+            }
+            else {
+                agg.addOutOfScopeItems([{ description: existing.description, relatedGoals: existing.relatedGoals }], undefined, existing.source);
+            }
+        }
+        const revSrc = ctx.currentSource;
+        agg.addInScopeItems(extraction.inScope ?? [], undefined, revSrc);
+        agg.addOutOfScopeItems(extraction.outOfScope ?? [], undefined, revSrc);
+        const revRemovedIds = new Set(extraction.removedIds ?? []);
+        if (revRemovedIds.size > 0) {
+            agg.removeScopeItems(revRemovedIds);
+        }
+        agg.addWaitingRoomItems(extraction.waitingRoomItems ?? []);
+        // Post-revision dedup: revision may add items that overlap existing ones
+        if (artifacts.inScope.length + artifacts.outOfScope.length >= 2) {
+            const dedupResult = await ctx.infer(scopeDedup(artifacts, "post-revision"));
+            for (const group of dedupResult.duplicateGroups ?? []) {
+                const validRemoveIds = group.removeIds.filter((id) => artifacts.inScope.some((s) => s.id === id) || artifacts.outOfScope.some((s) => s.id === id));
+                if (validRemoveIds.length > 0) {
+                    agg.removeScopeItems(new Set(validRemoveIds));
+                }
+            }
+        }
+    }
+    agg.confirmScope();
+}
+//# sourceMappingURL=scope.js.map