@wildo-ai/saas-models 1.1.7 → 1.1.9

package/dist/esm/meta-workflows/elicitation-depth.meta-workflows.shared.schemas.d.ts

@@ -0,0 +1,128 @@
+import { HumanDecision_FieldKind } from '../flows-actors/human-decision.shared.schemas';
+/**
+ * How deep an interview goes, and what happens when the creator does not know an answer (#2129).
+ *
+ * ## The problem these two vocabularies solve
+ *
+ * Every question a playbook declares used to be mandatory and the person's alone. The vision interview
+ * asks sixteen. A creator who answered "I don't know" — and most first-time creators will, about a
+ * mission statement or a "why now" — had no way forward: the run refused while any question was
+ * unanswered, and nothing could answer in their place without recording a guess as their decision.
+ *
+ * That is the defect `.claude/rules/application-creation-directive.md` names: a REQUIRED declaration
+ * whose absence stops the mechanism. Its remedy is to make the missing state REPRESENTABLE and keep going.
+ * So each question now says two things about itself:
+ *
+ * - its {@link MetaWorkflow_ElicitationQuestionDepth}: whether a SIMPLE interview asks it at all, or
+ *   leaves it to be proposed;
+ * - its {@link MetaWorkflow_ElicitationUnknownPolicy}: whether the companion may propose an answer when
+ *   the creator does not give one, or whether only the creator can answer it.
+ *
+ * A proposed answer is never recorded as the creator's decision: the dossier stores it as an ASSUMPTION
+ * (`ApplicationCreatorInputAnswerStanding.ASSUMED`), and the run is told it is one.
+ *
+ * ## Why both are optional on the question, with one resolver each
+ *
+ * Absence has one meaning per axis, stated in {@link resolveElicitationQuestionDepth} and
+ * {@link resolveElicitationUnknownPolicy}, and every reader goes through them. A `.default()` on the
+ * schema would change the inferred OUTPUT type of every elicitation spec, so every consumer that builds
+ * one by hand would need both fields; a resolver keeps the catalog terse and the meaning in one place.
+ */
+/**
+ * Which interview depth asks a question.
+ *
+ * The APPLICATION chooses a depth once (`ApplicationInterviewDepth`, recorded in its dossier): a SIMPLE
+ * interview asks only the {@link ESSENTIAL} questions and proposes the rest, recorded as assumptions the creator
+ * reviews (when a surface is open) or revisits afterwards (when an unattended round recorded them); a DETAILED
+ * interview asks every question.
+ */
+export declare enum MetaWorkflow_ElicitationQuestionDepth {
+    /**
+     * Asked at every depth. The questions the rest of the playbook cannot reasonably be proposed without —
+     * what the product is, and the problem it solves. Also the default for a question that declares no
+     * depth: a question nobody classified is asked rather than silently proposed.
+     */
+    ESSENTIAL = "essential",
+    /**
+     * Asked only by a DETAILED interview. A SIMPLE one proposes it from the essential answers instead of
+     * asking it: on an open surface the creator reviews the proposal with the others, and an unattended round
+     * records it as an assumption straight away, which the creator revisits afterwards (#2129) — except a
+     * regulated-domain question, which an unattended round never assumes: its playbook waits for the person.
+     */
+    DETAIL = "detail"
+}
+/**
+ * What may answer a question the creator does not answer.
+ */
+export declare enum MetaWorkflow_ElicitationUnknownPolicy {
+    /**
+     * The companion may PROPOSE an answer from what the creator already said and what the application
+     * already holds. What is kept is recorded as an assumption, never as their decision: kept by the creator
+     * on review, or — in a quick interview — recorded by an unattended round with nobody present and listed for
+     * the creator to revisit. The default: an answer that is marked as assumed is strictly better than an
+     * interview that cannot finish.
+     */
+    PROPOSE = "propose",
+    /**
+     * Only the creator can answer. For a decision that changes what the application IS rather than what it
+     * contains — the application's line, which decides which playbooks it runs. An answer recorded as
+     * assumed is refused for such a question.
+     */
+    ASK = "ask"
+}
+/**
+ * How deep this application's interviews go (#2129). Chosen by the creator once, at the start of creation,
+ * and recorded in the dossier because it is a fact about how THIS application's decisions were made — not a
+ * preference of whoever is typing on this machine.
+ */
+export declare enum ApplicationInterviewDepth {
+    /**
+     * Ask only each interview's ESSENTIAL questions; propose the rest from those answers. A surface the
+     * creator is using shows the proposals for review; an unattended round records them as assumptions and
+     * goes on, and they are listed to revisit — unless a regulated-domain question (or one only the creator may
+     * answer) is still waiting, in which case it assumes nothing for that playbook, which waits for the person. What a creator who does not want to write a vision document chooses.
+     */
+    SIMPLE = "simple",
+    /** Ask every question. Anything the creator does not know can still be proposed, one question at a time. */
+    DETAILED = "detailed"
+}
+/** The shape the resolvers read: the optional disposition fields of an elicitation question, and what it offers. */
+export interface MetaWorkflow_ElicitationQuestionDisposition {
+    readonly depth?: MetaWorkflow_ElicitationQuestionDepth | undefined;
+    readonly whenUnknown?: MetaWorkflow_ElicitationUnknownPolicy | undefined;
+    readonly regulatedDomain?: boolean | undefined;
+    readonly kind?: HumanDecision_FieldKind | undefined;
+    readonly options?: readonly string[] | undefined;
+}
+/**
+ * Whether an answer to this question may be PROPOSED — and so recorded as an assumption (#2129): its policy
+ * allows it, and it offers something to propose from (a CHOICE whose options are computed and not offered yet
+ * offers nothing). The ONE place proposability is decided.
+ */
+export declare function isElicitationQuestionProposable(question: MetaWorkflow_ElicitationQuestionDisposition): boolean;
+/**
+ * Whether a SIMPLE interview asks the question of the person (#2129): an ESSENTIAL question, or any question
+ * that cannot be proposed — one only the person may answer, or a choice with nothing to offer yet — since a
+ * short interview that skipped it could neither propose it nor finish. The ONE predicate every surface uses
+ * (console queue, workbench interview, conversation, plugin), so they cannot disagree about what is asked.
+ */
+export declare function isElicitationQuestionAskedInSimpleInterview(question: MetaWorkflow_ElicitationQuestionDisposition): boolean;
+/**
+ * Whether the question concerns a REGULATED DOMAIN (#2129) — regulated or specially protected data, a regulated
+ * sector, the jurisdictions a regime turns on. Such a question may still be proposed (Paul, 2026-10-01), but
+ * every surface names a proposed answer to it explicitly before the person keeps it, because those answers
+ * decide which compliance work matters later — so an unattended round never assumes one, and its playbook waits
+ * for the person. Absent means no.
+ */
+export declare function isRegulatedDomainElicitationQuestion(question: MetaWorkflow_ElicitationQuestionDisposition): boolean;
+/**
+ * The question's depth — {@link MetaWorkflow_ElicitationQuestionDepth.ESSENTIAL} when it declares none.
+ * The ONE place absence is interpreted.
+ */
+export declare function resolveElicitationQuestionDepth(question: MetaWorkflow_ElicitationQuestionDisposition): MetaWorkflow_ElicitationQuestionDepth;
+/**
+ * The question's unknown-answer policy — {@link MetaWorkflow_ElicitationUnknownPolicy.PROPOSE} when it
+ * declares none. The ONE place absence is interpreted.
+ */
+export declare function resolveElicitationUnknownPolicy(question: MetaWorkflow_ElicitationQuestionDisposition): MetaWorkflow_ElicitationUnknownPolicy;
+//# sourceMappingURL=elicitation-depth.meta-workflows.shared.schemas.d.ts.map

package/dist/esm/meta-workflows/elicitation-depth.meta-workflows.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elicitation-depth.meta-workflows.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/meta-workflows/elicitation-depth.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AAExF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;GAOG;AACH,oBAAY,qCAAqC;IAC/C;;;;OAIG;IACH,SAAS,cAAc;IACvB;;;;;OAKG;IACH,MAAM,WAAW;CAClB;AAED;;GAEG;AACH,oBAAY,qCAAqC;IAC/C;;;;;;OAMG;IACH,OAAO,YAAY;IACnB;;;;OAIG;IACH,GAAG,QAAQ;CACZ;AAED;;;;GAIG;AACH,oBAAY,yBAAyB;IACnC;;;;;OAKG;IACH,MAAM,WAAW;IACjB,4GAA4G;IAC5G,QAAQ,aAAa;CACtB;AAED,oHAAoH;AACpH,MAAM,WAAW,2CAA2C;IAC1D,QAAQ,CAAC,KAAK,CAAC,EAAE,qCAAqC,GAAG,SAAS,CAAC;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,qCAAqC,GAAG,SAAS,CAAC;IACzE,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,IAAI,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;CAClD;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,2CAA2C,GAAG,OAAO,CAG9G;AAED;;;;;GAKG;AACH,wBAAgB,2CAA2C,CAAC,QAAQ,EAAE,2CAA2C,GAAG,OAAO,CAG1H;AAED;;;;;;GAMG;AACH,wBAAgB,oCAAoC,CAAC,QAAQ,EAAE,2CAA2C,GAAG,OAAO,CAEnH;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,2CAA2C,GAAG,qCAAqC,CAE5I;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,2CAA2C,GAAG,qCAAqC,CAE5I"}

package/dist/esm/meta-workflows/elicitation-depth.meta-workflows.shared.schemas.js

@@ -0,0 +1,136 @@
+import { HumanDecision_FieldKind } from '../flows-actors/human-decision.shared.schemas.js';
+/**
+ * How deep an interview goes, and what happens when the creator does not know an answer (#2129).
+ *
+ * ## The problem these two vocabularies solve
+ *
+ * Every question a playbook declares used to be mandatory and the person's alone. The vision interview
+ * asks sixteen. A creator who answered "I don't know" — and most first-time creators will, about a
+ * mission statement or a "why now" — had no way forward: the run refused while any question was
+ * unanswered, and nothing could answer in their place without recording a guess as their decision.
+ *
+ * That is the defect `.claude/rules/application-creation-directive.md` names: a REQUIRED declaration
+ * whose absence stops the mechanism. Its remedy is to make the missing state REPRESENTABLE and keep going.
+ * So each question now says two things about itself:
+ *
+ * - its {@link MetaWorkflow_ElicitationQuestionDepth}: whether a SIMPLE interview asks it at all, or
+ *   leaves it to be proposed;
+ * - its {@link MetaWorkflow_ElicitationUnknownPolicy}: whether the companion may propose an answer when
+ *   the creator does not give one, or whether only the creator can answer it.
+ *
+ * A proposed answer is never recorded as the creator's decision: the dossier stores it as an ASSUMPTION
+ * (`ApplicationCreatorInputAnswerStanding.ASSUMED`), and the run is told it is one.
+ *
+ * ## Why both are optional on the question, with one resolver each
+ *
+ * Absence has one meaning per axis, stated in {@link resolveElicitationQuestionDepth} and
+ * {@link resolveElicitationUnknownPolicy}, and every reader goes through them. A `.default()` on the
+ * schema would change the inferred OUTPUT type of every elicitation spec, so every consumer that builds
+ * one by hand would need both fields; a resolver keeps the catalog terse and the meaning in one place.
+ */
+/**
+ * Which interview depth asks a question.
+ *
+ * The APPLICATION chooses a depth once (`ApplicationInterviewDepth`, recorded in its dossier): a SIMPLE
+ * interview asks only the {@link ESSENTIAL} questions and proposes the rest, recorded as assumptions the creator
+ * reviews (when a surface is open) or revisits afterwards (when an unattended round recorded them); a DETAILED
+ * interview asks every question.
+ */
+export var MetaWorkflow_ElicitationQuestionDepth;
+(function (MetaWorkflow_ElicitationQuestionDepth) {
+    /**
+     * Asked at every depth. The questions the rest of the playbook cannot reasonably be proposed without —
+     * what the product is, and the problem it solves. Also the default for a question that declares no
+     * depth: a question nobody classified is asked rather than silently proposed.
+     */
+    MetaWorkflow_ElicitationQuestionDepth["ESSENTIAL"] = "essential";
+    /**
+     * Asked only by a DETAILED interview. A SIMPLE one proposes it from the essential answers instead of
+     * asking it: on an open surface the creator reviews the proposal with the others, and an unattended round
+     * records it as an assumption straight away, which the creator revisits afterwards (#2129) — except a
+     * regulated-domain question, which an unattended round never assumes: its playbook waits for the person.
+     */
+    MetaWorkflow_ElicitationQuestionDepth["DETAIL"] = "detail";
+})(MetaWorkflow_ElicitationQuestionDepth || (MetaWorkflow_ElicitationQuestionDepth = {}));
+/**
+ * What may answer a question the creator does not answer.
+ */
+export var MetaWorkflow_ElicitationUnknownPolicy;
+(function (MetaWorkflow_ElicitationUnknownPolicy) {
+    /**
+     * The companion may PROPOSE an answer from what the creator already said and what the application
+     * already holds. What is kept is recorded as an assumption, never as their decision: kept by the creator
+     * on review, or — in a quick interview — recorded by an unattended round with nobody present and listed for
+     * the creator to revisit. The default: an answer that is marked as assumed is strictly better than an
+     * interview that cannot finish.
+     */
+    MetaWorkflow_ElicitationUnknownPolicy["PROPOSE"] = "propose";
+    /**
+     * Only the creator can answer. For a decision that changes what the application IS rather than what it
+     * contains — the application's line, which decides which playbooks it runs. An answer recorded as
+     * assumed is refused for such a question.
+     */
+    MetaWorkflow_ElicitationUnknownPolicy["ASK"] = "ask";
+})(MetaWorkflow_ElicitationUnknownPolicy || (MetaWorkflow_ElicitationUnknownPolicy = {}));
+/**
+ * How deep this application's interviews go (#2129). Chosen by the creator once, at the start of creation,
+ * and recorded in the dossier because it is a fact about how THIS application's decisions were made — not a
+ * preference of whoever is typing on this machine.
+ */
+export var ApplicationInterviewDepth;
+(function (ApplicationInterviewDepth) {
+    /**
+     * Ask only each interview's ESSENTIAL questions; propose the rest from those answers. A surface the
+     * creator is using shows the proposals for review; an unattended round records them as assumptions and
+     * goes on, and they are listed to revisit — unless a regulated-domain question (or one only the creator may
+     * answer) is still waiting, in which case it assumes nothing for that playbook, which waits for the person. What a creator who does not want to write a vision document chooses.
+     */
+    ApplicationInterviewDepth["SIMPLE"] = "simple";
+    /** Ask every question. Anything the creator does not know can still be proposed, one question at a time. */
+    ApplicationInterviewDepth["DETAILED"] = "detailed";
+})(ApplicationInterviewDepth || (ApplicationInterviewDepth = {}));
+/**
+ * Whether an answer to this question may be PROPOSED — and so recorded as an assumption (#2129): its policy
+ * allows it, and it offers something to propose from (a CHOICE whose options are computed and not offered yet
+ * offers nothing). The ONE place proposability is decided.
+ */
+export function isElicitationQuestionProposable(question) {
+    if (resolveElicitationUnknownPolicy(question) !== MetaWorkflow_ElicitationUnknownPolicy.PROPOSE)
+        return false;
+    return !(question.kind === HumanDecision_FieldKind.CHOICE && (question.options ?? []).length === 0);
+}
+/**
+ * Whether a SIMPLE interview asks the question of the person (#2129): an ESSENTIAL question, or any question
+ * that cannot be proposed — one only the person may answer, or a choice with nothing to offer yet — since a
+ * short interview that skipped it could neither propose it nor finish. The ONE predicate every surface uses
+ * (console queue, workbench interview, conversation, plugin), so they cannot disagree about what is asked.
+ */
+export function isElicitationQuestionAskedInSimpleInterview(question) {
+    return resolveElicitationQuestionDepth(question) === MetaWorkflow_ElicitationQuestionDepth.ESSENTIAL
+        || !isElicitationQuestionProposable(question);
+}
+/**
+ * Whether the question concerns a REGULATED DOMAIN (#2129) — regulated or specially protected data, a regulated
+ * sector, the jurisdictions a regime turns on. Such a question may still be proposed (Paul, 2026-10-01), but
+ * every surface names a proposed answer to it explicitly before the person keeps it, because those answers
+ * decide which compliance work matters later — so an unattended round never assumes one, and its playbook waits
+ * for the person. Absent means no.
+ */
+export function isRegulatedDomainElicitationQuestion(question) {
+    return question.regulatedDomain === true;
+}
+/**
+ * The question's depth — {@link MetaWorkflow_ElicitationQuestionDepth.ESSENTIAL} when it declares none.
+ * The ONE place absence is interpreted.
+ */
+export function resolveElicitationQuestionDepth(question) {
+    return question.depth ?? MetaWorkflow_ElicitationQuestionDepth.ESSENTIAL;
+}
+/**
+ * The question's unknown-answer policy — {@link MetaWorkflow_ElicitationUnknownPolicy.PROPOSE} when it
+ * declares none. The ONE place absence is interpreted.
+ */
+export function resolveElicitationUnknownPolicy(question) {
+    return question.whenUnknown ?? MetaWorkflow_ElicitationUnknownPolicy.PROPOSE;
+}
+//# sourceMappingURL=elicitation-depth.meta-workflows.shared.schemas.js.map

package/dist/esm/meta-workflows/elicitation-depth.meta-workflows.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elicitation-depth.meta-workflows.shared.schemas.js","sourceRoot":"","sources":["../../../../src/meta-workflows/elicitation-depth.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AAExF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAN,IAAY,qCAcX;AAdD,WAAY,qCAAqC;IAC/C;;;;OAIG;IACH,gEAAuB,CAAA;IACvB;;;;;OAKG;IACH,0DAAiB,CAAA;AACnB,CAAC,EAdW,qCAAqC,KAArC,qCAAqC,QAchD;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,qCAeX;AAfD,WAAY,qCAAqC;IAC/C;;;;;;OAMG;IACH,4DAAmB,CAAA;IACnB;;;;OAIG;IACH,oDAAW,CAAA;AACb,CAAC,EAfW,qCAAqC,KAArC,qCAAqC,QAehD;AAED;;;;GAIG;AACH,MAAM,CAAN,IAAY,yBAUX;AAVD,WAAY,yBAAyB;IACnC;;;;;OAKG;IACH,8CAAiB,CAAA;IACjB,4GAA4G;IAC5G,kDAAqB,CAAA;AACvB,CAAC,EAVW,yBAAyB,KAAzB,yBAAyB,QAUpC;AAWD;;;;GAIG;AACH,MAAM,UAAU,+BAA+B,CAAC,QAAqD;IACnG,IAAI,+BAA+B,CAAC,QAAQ,CAAC,KAAK,qCAAqC,CAAC,OAAO;QAAE,OAAO,KAAK,CAAC;IAC9G,OAAO,CAAC,CAAC,QAAQ,CAAC,IAAI,KAAK,uBAAuB,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC;AACtG,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,2CAA2C,CAAC,QAAqD;IAC/G,OAAO,+BAA+B,CAAC,QAAQ,CAAC,KAAK,qCAAqC,CAAC,SAAS;WAC/F,CAAC,+BAA+B,CAAC,QAAQ,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oCAAoC,CAAC,QAAqD;IACxG,OAAO,QAAQ,CAAC,eAAe,KAAK,IAAI,CAAC;AAC3C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,+BAA+B,CAAC,QAAqD;IACnG,OAAO,QAAQ,CAAC,KAAK,IAAI,qCAAqC,CAAC,SAAS,CAAC;AAC3E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,+BAA+B,CAAC,QAAqD;IACnG,OAAO,QAAQ,CAAC,WAAW,IAAI,qCAAqC,CAAC,OAAO,CAAC;AAC/E,CAAC","sourcesContent":["import { HumanDecision_FieldKind } from '../flows-actors/human-decision.shared.schemas';\n\n/**\n * How deep an interview goes, and what happens when the creator does not know an answer (#2129).\n *\n * ## The problem these two vocabularies solve\n *\n * Every question a playbook declares used to be mandatory and the person's alone. The vision interview\n * asks sixteen. A creator who answered \"I don't know\" — and most first-time creators will, about a\n * mission statement or a \"why now\" — had no way forward: the run refused while any question was\n * unanswered, and nothing could answer in their place without recording a guess as their decision.\n *\n * That is the defect `.claude/rules/application-creation-directive.md` names: a REQUIRED declaration\n * whose absence stops the mechanism. Its remedy is to make the missing state REPRESENTABLE and keep going.\n * So each question now says two things about itself:\n *\n * - its {@link MetaWorkflow_ElicitationQuestionDepth}: whether a SIMPLE interview asks it at all, or\n *   leaves it to be proposed;\n * - its {@link MetaWorkflow_ElicitationUnknownPolicy}: whether the companion may propose an answer when\n *   the creator does not give one, or whether only the creator can answer it.\n *\n * A proposed answer is never recorded as the creator's decision: the dossier stores it as an ASSUMPTION\n * (`ApplicationCreatorInputAnswerStanding.ASSUMED`), and the run is told it is one.\n *\n * ## Why both are optional on the question, with one resolver each\n *\n * Absence has one meaning per axis, stated in {@link resolveElicitationQuestionDepth} and\n * {@link resolveElicitationUnknownPolicy}, and every reader goes through them. A `.default()` on the\n * schema would change the inferred OUTPUT type of every elicitation spec, so every consumer that builds\n * one by hand would need both fields; a resolver keeps the catalog terse and the meaning in one place.\n */\n\n/**\n * Which interview depth asks a question.\n *\n * The APPLICATION chooses a depth once (`ApplicationInterviewDepth`, recorded in its dossier): a SIMPLE\n * interview asks only the {@link ESSENTIAL} questions and proposes the rest, recorded as assumptions the creator\n * reviews (when a surface is open) or revisits afterwards (when an unattended round recorded them); a DETAILED\n * interview asks every question.\n */\nexport enum MetaWorkflow_ElicitationQuestionDepth {\n  /**\n   * Asked at every depth. The questions the rest of the playbook cannot reasonably be proposed without —\n   * what the product is, and the problem it solves. Also the default for a question that declares no\n   * depth: a question nobody classified is asked rather than silently proposed.\n   */\n  ESSENTIAL = 'essential',\n  /**\n   * Asked only by a DETAILED interview. A SIMPLE one proposes it from the essential answers instead of\n   * asking it: on an open surface the creator reviews the proposal with the others, and an unattended round\n   * records it as an assumption straight away, which the creator revisits afterwards (#2129) — except a\n   * regulated-domain question, which an unattended round never assumes: its playbook waits for the person.\n   */\n  DETAIL = 'detail',\n}\n\n/**\n * What may answer a question the creator does not answer.\n */\nexport enum MetaWorkflow_ElicitationUnknownPolicy {\n  /**\n   * The companion may PROPOSE an answer from what the creator already said and what the application\n   * already holds. What is kept is recorded as an assumption, never as their decision: kept by the creator\n   * on review, or — in a quick interview — recorded by an unattended round with nobody present and listed for\n   * the creator to revisit. The default: an answer that is marked as assumed is strictly better than an\n   * interview that cannot finish.\n   */\n  PROPOSE = 'propose',\n  /**\n   * Only the creator can answer. For a decision that changes what the application IS rather than what it\n   * contains — the application's line, which decides which playbooks it runs. An answer recorded as\n   * assumed is refused for such a question.\n   */\n  ASK = 'ask',\n}\n\n/**\n * How deep this application's interviews go (#2129). Chosen by the creator once, at the start of creation,\n * and recorded in the dossier because it is a fact about how THIS application's decisions were made — not a\n * preference of whoever is typing on this machine.\n */\nexport enum ApplicationInterviewDepth {\n  /**\n   * Ask only each interview's ESSENTIAL questions; propose the rest from those answers. A surface the\n   * creator is using shows the proposals for review; an unattended round records them as assumptions and\n   * goes on, and they are listed to revisit — unless a regulated-domain question (or one only the creator may\n   * answer) is still waiting, in which case it assumes nothing for that playbook, which waits for the person. What a creator who does not want to write a vision document chooses.\n   */\n  SIMPLE = 'simple',\n  /** Ask every question. Anything the creator does not know can still be proposed, one question at a time. */\n  DETAILED = 'detailed',\n}\n\n/** The shape the resolvers read: the optional disposition fields of an elicitation question, and what it offers. */\nexport interface MetaWorkflow_ElicitationQuestionDisposition {\n  readonly depth?: MetaWorkflow_ElicitationQuestionDepth | undefined;\n  readonly whenUnknown?: MetaWorkflow_ElicitationUnknownPolicy | undefined;\n  readonly regulatedDomain?: boolean | undefined;\n  readonly kind?: HumanDecision_FieldKind | undefined;\n  readonly options?: readonly string[] | undefined;\n}\n\n/**\n * Whether an answer to this question may be PROPOSED — and so recorded as an assumption (#2129): its policy\n * allows it, and it offers something to propose from (a CHOICE whose options are computed and not offered yet\n * offers nothing). The ONE place proposability is decided.\n */\nexport function isElicitationQuestionProposable(question: MetaWorkflow_ElicitationQuestionDisposition): boolean {\n  if (resolveElicitationUnknownPolicy(question) !== MetaWorkflow_ElicitationUnknownPolicy.PROPOSE) return false;\n  return !(question.kind === HumanDecision_FieldKind.CHOICE && (question.options ?? []).length === 0);\n}\n\n/**\n * Whether a SIMPLE interview asks the question of the person (#2129): an ESSENTIAL question, or any question\n * that cannot be proposed — one only the person may answer, or a choice with nothing to offer yet — since a\n * short interview that skipped it could neither propose it nor finish. The ONE predicate every surface uses\n * (console queue, workbench interview, conversation, plugin), so they cannot disagree about what is asked.\n */\nexport function isElicitationQuestionAskedInSimpleInterview(question: MetaWorkflow_ElicitationQuestionDisposition): boolean {\n  return resolveElicitationQuestionDepth(question) === MetaWorkflow_ElicitationQuestionDepth.ESSENTIAL\n    || !isElicitationQuestionProposable(question);\n}\n\n/**\n * Whether the question concerns a REGULATED DOMAIN (#2129) — regulated or specially protected data, a regulated\n * sector, the jurisdictions a regime turns on. Such a question may still be proposed (Paul, 2026-10-01), but\n * every surface names a proposed answer to it explicitly before the person keeps it, because those answers\n * decide which compliance work matters later — so an unattended round never assumes one, and its playbook waits\n * for the person. Absent means no.\n */\nexport function isRegulatedDomainElicitationQuestion(question: MetaWorkflow_ElicitationQuestionDisposition): boolean {\n  return question.regulatedDomain === true;\n}\n\n/**\n * The question's depth — {@link MetaWorkflow_ElicitationQuestionDepth.ESSENTIAL} when it declares none.\n * The ONE place absence is interpreted.\n */\nexport function resolveElicitationQuestionDepth(question: MetaWorkflow_ElicitationQuestionDisposition): MetaWorkflow_ElicitationQuestionDepth {\n  return question.depth ?? MetaWorkflow_ElicitationQuestionDepth.ESSENTIAL;\n}\n\n/**\n * The question's unknown-answer policy — {@link MetaWorkflow_ElicitationUnknownPolicy.PROPOSE} when it\n * declares none. The ONE place absence is interpreted.\n */\nexport function resolveElicitationUnknownPolicy(question: MetaWorkflow_ElicitationQuestionDisposition): MetaWorkflow_ElicitationUnknownPolicy {\n  return question.whenUnknown ?? MetaWorkflow_ElicitationUnknownPolicy.PROPOSE;\n}\n"]}

package/dist/esm/meta-workflows/orchestration.meta-workflows.shared.schemas.d.ts

@@ -36,6 +36,7 @@ import { z } from "zod";
 import { ExpertWorkDomain } from "../flows-actors/deliberation.shared.schemas";
 import { HumanDecision_FieldKind } from "../flows-actors/human-decision.shared.schemas";
 import { MetaWorkflow_EvaluationVerdict } from "./decisions.meta-workflows.shared.schemas";
+import { MetaWorkflow_ElicitationQuestionDepth, MetaWorkflow_ElicitationUnknownPolicy } from "./elicitation-depth.meta-workflows.shared.schemas";
 /**
  * Which execution tier runs a playbook (design plan D4):
  * - COMPANION_AGENT — API-transport LLM agent invoked by the companion
@@ -469,16 +470,46 @@ declare const _MetaWorkflow_JourneyPredicateSchema: z.ZodDiscriminatedUnion<[z.Z
 }, z.core.$strip>], "kind">;
 export declare const MetaWorkflow_JourneyPredicateSchema: typeof _MetaWorkflow_JourneyPredicateSchema;
 export type MetaWorkflow_JourneyPredicate = z.infer<typeof _MetaWorkflow_JourneyPredicateSchema>;
+/**
+ * Where an interview CHOICE question's options come from, when they cannot be written into the catalog
+ * because they depend on what the application has already decided.
+ *
+ * ## Why a named source, and not a model-written question
+ *
+ * The brand name is the case that forced it. The creator should CHOOSE among names the companion proposed
+ * and screened, so the options are the landed screening's candidates — a different list for every
+ * application. A mid-run clarification could ask that, but its options are written by the model and its
+ * question call fails soft (no question, the run proceeds), which would let the model pick the name
+ * itself. A named source is computed by code from landed families, so the options are the same every time
+ * they are read, and a creator's answer is checked against exactly the list they were shown.
+ *
+ * One member per source, each resolved by ONE runtime function; the resolver map is total over this enum,
+ * so a member added without its resolver does not compile. A question declaring a source must be a CHOICE
+ * and must not ALSO declare `options` — the catalog test holds both.
+ */
+export declare enum MetaWorkflow_ElicitationOptionsSource {
+    /**
+     * The screened brand-name candidates the creator may choose — computed from the landed
+     * `brand-name-screening` and the market snapshot's competitors (`deriveOfferableBrandNameOptions`).
+     * A conflicting companion proposal is never offered; a conflicting creator-supplied name is offered only
+     * as an explicit "keep despite conflict" option.
+     */
+    BRAND_NAME_SCREENING_CANDIDATES = "brand_name_screening_candidates"
+}
 export declare const MetaWorkflow_ElicitationSpecSchema: z.ZodObject<{
     questions: z.ZodArray<z.ZodObject<{
         ref: z.ZodString;
         question: z.ZodString;
         kind: z.ZodEnum<typeof HumanDecision_FieldKind>;
         options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        optionsFrom: z.ZodOptional<z.ZodEnum<typeof MetaWorkflow_ElicitationOptionsSource>>;
         sameDecisionAs: z.ZodOptional<z.ZodObject<{
             playbookRef: z.ZodString;
             questionRef: z.ZodString;
         }, z.core.$strip>>;
+        depth: z.ZodOptional<z.ZodEnum<typeof MetaWorkflow_ElicitationQuestionDepth>>;
+        whenUnknown: z.ZodOptional<z.ZodEnum<typeof MetaWorkflow_ElicitationUnknownPolicy>>;
+        regulatedDomain: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type MetaWorkflow_ElicitationSpec = z.infer<typeof MetaWorkflow_ElicitationSpecSchema>;
@@ -613,6 +644,7 @@ export declare const MetaWorkflow_ChoreographySchema: z.ZodObject<{
         reopen: z.ZodArray<z.ZodString>;
     }, z.core.$strict>>>;
     actsOnApplication: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    closingMove: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type MetaWorkflow_Choreography = z.infer<typeof MetaWorkflow_ChoreographySchema>;
 /**

package/dist/esm/meta-workflows/orchestration.meta-workflows.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orchestration.meta-workflows.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/meta-workflows/orchestration.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"orchestration.meta-workflows.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/meta-workflows/orchestration.meta-workflows.shared.schemas.ts"],"names":[],"mappings":"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"}

package/dist/esm/meta-workflows/orchestration.meta-workflows.shared.schemas.js

@@ -36,6 +36,7 @@ import { z } from "zod";
 import { ExpertWorkDomain } from "../flows-actors/deliberation.shared.schemas.js";
 import { HumanDecision_FieldKind } from "../flows-actors/human-decision.shared.schemas.js";
 import { MetaWorkflow_EvaluationVerdict } from "./decisions.meta-workflows.shared.schemas.js";
+import { MetaWorkflow_ElicitationQuestionDepth, MetaWorkflow_ElicitationUnknownPolicy } from "./elicitation-depth.meta-workflows.shared.schemas.js";
 /**
  * Which execution tier runs a playbook (design plan D4):
  * - COMPANION_AGENT — API-transport LLM agent invoked by the companion
@@ -514,14 +515,47 @@ const _MetaWorkflow_JourneyPredicateSchema = z.discriminatedUnion("kind", [
     }),
 ]);
 export const MetaWorkflow_JourneyPredicateSchema = _MetaWorkflow_JourneyPredicateSchema;
+/**
+ * Where an interview CHOICE question's options come from, when they cannot be written into the catalog
+ * because they depend on what the application has already decided.
+ *
+ * ## Why a named source, and not a model-written question
+ *
+ * The brand name is the case that forced it. The creator should CHOOSE among names the companion proposed
+ * and screened, so the options are the landed screening's candidates — a different list for every
+ * application. A mid-run clarification could ask that, but its options are written by the model and its
+ * question call fails soft (no question, the run proceeds), which would let the model pick the name
+ * itself. A named source is computed by code from landed families, so the options are the same every time
+ * they are read, and a creator's answer is checked against exactly the list they were shown.
+ *
+ * One member per source, each resolved by ONE runtime function; the resolver map is total over this enum,
+ * so a member added without its resolver does not compile. A question declaring a source must be a CHOICE
+ * and must not ALSO declare `options` — the catalog test holds both.
+ */
+export var MetaWorkflow_ElicitationOptionsSource;
+(function (MetaWorkflow_ElicitationOptionsSource) {
+    /**
+     * The screened brand-name candidates the creator may choose — computed from the landed
+     * `brand-name-screening` and the market snapshot's competitors (`deriveOfferableBrandNameOptions`).
+     * A conflicting companion proposal is never offered; a conflicting creator-supplied name is offered only
+     * as an explicit "keep despite conflict" option.
+     */
+    MetaWorkflow_ElicitationOptionsSource["BRAND_NAME_SCREENING_CANDIDATES"] = "brand_name_screening_candidates";
+})(MetaWorkflow_ElicitationOptionsSource || (MetaWorkflow_ElicitationOptionsSource = {}));
 export const MetaWorkflow_ElicitationSpecSchema = z.object({
     questions: z
         .array(z.object({
         ref: z.string().min(1),
         question: z.string().min(1),
         kind: z.enum(HumanDecision_FieldKind),
-        /** Required when kind = CHOICE. */
+        /** Required when kind = CHOICE, unless `optionsFrom` computes them. */
         options: z.array(z.string().min(1)).optional(),
+        /**
+         * Computed options for a CHOICE (see {@link MetaWorkflow_ElicitationOptionsSource}). Resolved at every
+         * door that shows or accepts an answer; an answer to a question whose options were never resolved is
+         * refused rather than accepted unchecked.
+         */
+        optionsFrom: z.enum(MetaWorkflow_ElicitationOptionsSource).optional(),
         /**
          * The SAME DECISION another step already asks (#1454, gap 4): this question's answer IS that
          * question's answer, so the creator is asked once. The dossier lists the decision at the step
@@ -537,6 +571,21 @@ export const MetaWorkflow_ElicitationSpecSchema = z.object({
             playbookRef: z.string().min(1),
             questionRef: z.string().min(1),
         }).optional(),
+        /**
+         * Which interview depth asks it (#2129). Absent means ESSENTIAL — read it through
+         * `resolveElicitationQuestionDepth`, never directly.
+         */
+        depth: z.enum(MetaWorkflow_ElicitationQuestionDepth).optional(),
+        /**
+         * Whether the companion may propose an answer the creator does not give (#2129). Absent means
+         * PROPOSE — read it through `resolveElicitationUnknownPolicy`, never directly.
+         */
+        whenUnknown: z.enum(MetaWorkflow_ElicitationUnknownPolicy).optional(),
+        /**
+         * The question concerns a regulated domain (#2129): a proposed answer to it is named to the person
+         * explicitly before it is kept. Read it through `isRegulatedDomainElicitationQuestion`.
+         */
+        regulatedDomain: z.boolean().optional(),
     }))
         .min(1),
 });
@@ -711,8 +760,24 @@ export const MetaWorkflow_ChoreographySchema = z.object({
      * single-value family" would let a market-segment instance rewrite the application's market snapshot.
      */
     actsOnApplication: z.array(z.string().min(1)).optional(),
+    /**
+     * The admitted child this lane ENDS ON (#2236): a lane may not report itself finished before the closing move
+     * has run in that run. When the selector chooses to stop and the closing move has not run and is on offer, the
+     * runtime runs it instead of stopping; when it is not on offer, the lane ends anyway, the boundary records the
+     * closing move as UNRUN with the reason, and the lane no longer reads as concluded.
+     *
+     * It exists because a closing move that lands nothing — the definition lane's phase gate, whose output is a
+     * verdict — is never marked delivered, so "has it run?" was left to the selector reading the lane's intent text.
+     * Measured on app-creation-test-004 (2026-09-30): the definition lane's families landed, the run went on to
+     * conception, compliance and build, and the go/no-go decision never ran. Marking, not refusing: a closing move
+     * that cannot run never stops the lane (`.claude/rules/application-creation-directive.md`).
+     */
+    closingMove: z.string().min(1).optional(),
 }).superRefine((choreography, context) => {
     const admitted = new Set(choreography.admits);
+    if (choreography.closingMove !== undefined && !admitted.has(choreography.closingMove)) {
+        context.addIssue({ code: 'custom', path: ['closingMove'], message: `"${choreography.closingMove}" is not admitted by this composite, so the lane could never end on it.` });
+    }
     (choreography.actsOnApplication ?? []).forEach((ref, index) => {
         if (!admitted.has(ref)) {
             context.addIssue({ code: 'custom', path: ['actsOnApplication', index], message: `"${ref}" is not admitted by this composite, so it can never act for it.` });