@telora/daemon 0.16.42 → 0.17.1

package/dist/prompt-sections/persona-sections.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Persona and framing section builders: review-defect remediation directive,
+ * remediation framing, loop-data maintenance, the close-loop bookkeeper persona
+ * + drift check, and the incremental resume-delta message. Extracted from
+ * team-prompt-base.ts.
+ */
+import type { FocusIssueInfo } from '../types.js';
+/**
+ * Build the review-defect remediation directive.
+ *
+ * Emitted when the team is being respawned to address issues filed by a
+ * review pass (see review-defect-detector.ts). The directive orients the
+ * team to "fix defects, not expand scope" -- the open issues on this
+ * focus are review-filed defects, not net-new product work.
+ *
+ * Returns an empty array when no review-filed defects are pending. The
+ * caller decides when to include the section based on detector state.
+ */
+export declare function buildRemediationDirectiveSection(reviewFiledOpenCount: number): string[];
+/**
+ * The marker we look for in the assembled stage-directive context to know a
+ * review report is being rendered into the prompt. The focus.last_review_report
+ * resolver in assembly-resolvers.ts emits this exact heading.
+ */
+export declare const LAST_REVIEW_REPORT_HEADING = "## Last Review Report";
+/**
+ * Build the remediation framing line for a review-driven dev session.
+ *
+ * Detection signal: the assembled stage-directive context contains a
+ * non-empty `## Last Review Report` section. When present, emit a single
+ * framing line that orients the agent toward "you previously shipped this --
+ * address the gaps, do not redo correct work". When absent, emit nothing.
+ *
+ * Reads ONLY from the assembled context string. No DB calls -- the
+ * focus.last_review_report resolver is the source of truth for whether a
+ * report exists; this section is a renderer of that signal.
+ *
+ * The caller's responsibility is to render this section BEFORE the
+ * assembled context, so the framing line appears above the report content
+ * in the final prompt.
+ */
+export declare function buildRemediationFramingSection(assembledContext: string): string[];
+/**
+ * Build the loop maintenance directive section.
+ * Instructs the agent to proactively maintain loop data as it works,
+ * making its thinking visible to humans for review and correction.
+ */
+export declare function buildLoopMaintenanceSection(): string[];
+/**
+ * Build the close_loop bookkeeper persona.
+ *
+ * The close_loop stage runs a different kind of agent: a "bookkeeper" whose
+ * single mandate is to drive every anchored injection to a terminal state
+ * (verified or escalated) and emit the residual tree-drift / incomplete-
+ * planning signals. The persona is intentionally narrow and asymmetric --
+ * the only outcomes for an anchored injection are:
+ *
+ *   - verified  -> evidence in the worktree supports the FRT overlay flip;
+ *                   call telora_reality_tree_injection_verify(...).
+ *   - escalated -> evidence is absent or ambiguous; file an
+ *                   `injection_unverified` escalation. There is NO third
+ *                   option. The bookkeeper does not write code, does not
+ *                   propose new injections, and does not silently lower
+ *                   the bar by leaving an injection in `proposed` or
+ *                   `in_progress` indefinitely.
+ *
+ * Asymmetric bias: the system moves reality toward intent (verifying
+ * injections, retiring closed UDEs) but NEVER lowers intent toward the
+ * shipped reality (a delivery that did not actually flip its target UDE
+ * must escalate, not have its FRT overlay edited to match what shipped).
+ *
+ * The literal tokens "verified", "escalated", "no third option", "evidence",
+ * and "asymmetric" all appear verbatim so the persona is grep-verifiable
+ * by the close_loop directive tests and reviewers.
+ *
+ * Dispatched per stage `close_loop` -- the `loop.persona` resolver picks
+ * this variant when invoked with `variant=close_loop`, and the close_loop
+ * stage assembly recipe in the dispatcher uses `loop.persona(variant=close_loop)`.
+ */
+export declare function buildCloseLoopBookkeeperPersona(): string;
+/**
+ * Build the close_loop drift-check section.
+ *
+ * The close_loop stage agent (the focus "bookkeeper") propagates verified
+ * injection effects back into the CRT and checks the residual tree for drift
+ * against the focus statement. There is no stored apex node in the tree --
+ * `focus.description` is the implicit apex of the reality tree; UDEs
+ * articulate the gap between current reality and that statement.
+ *
+ * This section renders the focus statement verbatim and instructs the
+ * agent to compare residual UDEs against it. It MUST contain both the
+ * focus.description text and the literal token `tree_drift` so the
+ * directive-executor can confirm the close_loop prompt was assembled
+ * correctly (and so reviewers can grep for it).
+ *
+ * If `focusDescription` is null/empty, the section emits a notice that
+ * no apex statement is available and the drift check cannot be performed
+ * -- the agent should escalate.
+ *
+ * See:
+ * - Design principle "Tree-Focus Apex" in memory/design-principles.md
+ * - Wiki page "reality-trees-crt-frt-planning-layer", section
+ *   "Tree-Focus Apex Convention"
+ */
+export declare function buildCloseLoopDriftCheckSection(focusDescription: string | null | undefined): string[];
+/** Inputs for the incremental resume-delta message. */
+export interface ResumeDeltaContext {
+    /** Lineage being resumed (e.g. 'coding', 'review'). */
+    lineage: string;
+    /** Focus name for the framing line. */
+    focusName: string;
+    /** Assembled git.diff_against_base content (may be empty). */
+    gitDiff: string;
+    /**
+     * Open review-filed issues from the prior cycle. For the review lineage these
+     * are findings to re-verify; for coding they are defects to address.
+     */
+    priorFindings: FocusIssueInfo[];
+}
+/**
+ * Build the incremental delta message sent when a lineage's session is RESUMED
+ * (INJ-D). A resumed Claude session already holds its role framework, tools,
+ * status rules, and accumulated context -- re-sending the full prompt wastes
+ * tokens and re-anchors. The delta carries only what changed since the last
+ * cycle (the diff) plus the prior findings, deliberately omitting the
+ * role-framework sections.
+ *
+ * Anti-anchoring: for the review lineage the prior findings are framed as "to
+ * VERIFY, not trust" -- the diff and acceptance criteria remain ground truth
+ * each cycle, so a resumed reviewer re-examines rather than rubber-stamping.
+ */
+export declare function buildResumeDeltaMessage(ctx: ResumeDeltaContext): string;
+//# sourceMappingURL=persona-sections.d.ts.map

package/dist/prompt-sections/persona-sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persona-sections.d.ts","sourceRoot":"","sources":["../../src/prompt-sections/persona-sections.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAC9C,oBAAoB,EAAE,MAAM,GAC3B,MAAM,EAAE,CAqBV;AAED;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,0BAA0B,CAAC;AAElE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE,CAQjF;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,EAAE,CA8BtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,+BAA+B,IAAI,MAAM,CAuDxD;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,+BAA+B,CAC7C,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC1C,MAAM,EAAE,CAqCV;AAMD,uDAAuD;AACvD,MAAM,WAAW,kBAAkB;IACjC,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,EAAE,cAAc,EAAE,CAAC;CACjC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CA+CvE"}

package/dist/prompt-sections/persona-sections.js

@@ -0,0 +1,317 @@
+/**
+ * Persona and framing section builders: review-defect remediation directive,
+ * remediation framing, loop-data maintenance, the close-loop bookkeeper persona
+ * + drift check, and the incremental resume-delta message. Extracted from
+ * team-prompt-base.ts.
+ */
+/**
+ * Build the review-defect remediation directive.
+ *
+ * Emitted when the team is being respawned to address issues filed by a
+ * review pass (see review-defect-detector.ts). The directive orients the
+ * team to "fix defects, not expand scope" -- the open issues on this
+ * focus are review-filed defects, not net-new product work.
+ *
+ * Returns an empty array when no review-filed defects are pending. The
+ * caller decides when to include the section based on detector state.
+ */
+export function buildRemediationDirectiveSection(reviewFiledOpenCount) {
+    if (reviewFiledOpenCount <= 0)
+        return [];
+    return [
+        '### Review-Defect Remediation',
+        '',
+        `These deliveries contain ${reviewFiledOpenCount} open issue(s) filed by the`,
+        'review team after auditing your prior work. Address them as defects to',
+        'fix, not new scope to expand. Specifically:',
+        '',
+        '- Do NOT create additional deliveries unless directly required to fix a',
+        '  flagged defect.',
+        '- Do NOT widen scope. The review identified specific gaps -- close them.',
+        '- Issues filed during this review pass are tagged with `created_by_role_id`;',
+        '  treat them as the work plan for this remediation cycle.',
+        '- When all review-filed issues are Done, the daemon will automatically',
+        '  return the focus to verify so the next review pass can run.',
+        '',
+        'You are in a remediation cycle. The bound is small (default 3 cycles)',
+        'before escalation -- finish the defects efficiently and accurately.',
+        '',
+    ];
+}
+/**
+ * The marker we look for in the assembled stage-directive context to know a
+ * review report is being rendered into the prompt. The focus.last_review_report
+ * resolver in assembly-resolvers.ts emits this exact heading.
+ */
+export const LAST_REVIEW_REPORT_HEADING = '## Last Review Report';
+/**
+ * Build the remediation framing line for a review-driven dev session.
+ *
+ * Detection signal: the assembled stage-directive context contains a
+ * non-empty `## Last Review Report` section. When present, emit a single
+ * framing line that orients the agent toward "you previously shipped this --
+ * address the gaps, do not redo correct work". When absent, emit nothing.
+ *
+ * Reads ONLY from the assembled context string. No DB calls -- the
+ * focus.last_review_report resolver is the source of truth for whether a
+ * report exists; this section is a renderer of that signal.
+ *
+ * The caller's responsibility is to render this section BEFORE the
+ * assembled context, so the framing line appears above the report content
+ * in the final prompt.
+ */
+export function buildRemediationFramingSection(assembledContext) {
+    if (!assembledContext.includes(LAST_REVIEW_REPORT_HEADING))
+        return [];
+    return [
+        '## Remediation Mode',
+        '',
+        "You previously delivered this focus. Review identified the following gaps. Address them; don't redo already-correct work.",
+        '',
+    ];
+}
+/**
+ * Build the loop maintenance directive section.
+ * Instructs the agent to proactively maintain loop data as it works,
+ * making its thinking visible to humans for review and correction.
+ */
+export function buildLoopMaintenanceSection() {
+    return [
+        '### Loop Data Maintenance',
+        '',
+        'As you work, proactively maintain loop data to make your thinking visible.',
+        'Loop data is how humans review and correct your understanding. Treat it',
+        'as a mirror of your current mental model, not a report to write at the end.',
+        '',
+        '**When to update loop documents** (`telora_loop_document`):',
+        '- When your understanding of the focus or delivery shifts during work',
+        '- When you discover architectural constraints or tradeoffs not yet captured',
+        '- When a human correction reveals something about intent you did not have',
+        '- Re-rank documents when priorities shift (higher rank = more important)',
+        '',
+        '**When to generate questions** (`telora_loop_question`):',
+        '- When you encounter uncertainty or ambiguity in requirements',
+        '- When you see tradeoffs that may need human judgment',
+        '- When something seems inconsistent between layers (focus vs delivery)',
+        '- Use type "generated" and rank by importance (lower sort_order = higher priority)',
+        '',
+        '**When to answer questions** (`telora_loop_answer`):',
+        '- Answer fixed questions when you have a position based on your work',
+        '- Update answers when your position changes due to new information',
+        '- Answer your own generated questions when you reach conclusions',
+        '',
+        '**Cadence**: Update loop data at natural work boundaries -- after completing',
+        'an issue, when switching between deliveries, or when a significant insight',
+        'emerges. Do not batch all updates to the end of the session.',
+        '',
+    ];
+}
+/**
+ * Build the close_loop bookkeeper persona.
+ *
+ * The close_loop stage runs a different kind of agent: a "bookkeeper" whose
+ * single mandate is to drive every anchored injection to a terminal state
+ * (verified or escalated) and emit the residual tree-drift / incomplete-
+ * planning signals. The persona is intentionally narrow and asymmetric --
+ * the only outcomes for an anchored injection are:
+ *
+ *   - verified  -> evidence in the worktree supports the FRT overlay flip;
+ *                   call telora_reality_tree_injection_verify(...).
+ *   - escalated -> evidence is absent or ambiguous; file an
+ *                   `injection_unverified` escalation. There is NO third
+ *                   option. The bookkeeper does not write code, does not
+ *                   propose new injections, and does not silently lower
+ *                   the bar by leaving an injection in `proposed` or
+ *                   `in_progress` indefinitely.
+ *
+ * Asymmetric bias: the system moves reality toward intent (verifying
+ * injections, retiring closed UDEs) but NEVER lowers intent toward the
+ * shipped reality (a delivery that did not actually flip its target UDE
+ * must escalate, not have its FRT overlay edited to match what shipped).
+ *
+ * The literal tokens "verified", "escalated", "no third option", "evidence",
+ * and "asymmetric" all appear verbatim so the persona is grep-verifiable
+ * by the close_loop directive tests and reviewers.
+ *
+ * Dispatched per stage `close_loop` -- the `loop.persona` resolver picks
+ * this variant when invoked with `variant=close_loop`, and the close_loop
+ * stage assembly recipe in the dispatcher uses `loop.persona(variant=close_loop)`.
+ */
+export function buildCloseLoopBookkeeperPersona() {
+    return [
+        '## Persona: Close-Loop Bookkeeper',
+        '',
+        'You are the focus bookkeeper. The focus has reached the `close_loop` stage,',
+        'which means all deliveries are settled and review has converged. Your job',
+        'is NOT to write code, NOT to widen scope, NOT to propose new injections.',
+        'Your job is to drive every anchored injection on this focus to a terminal',
+        'state.',
+        '',
+        '**Per-injection sweep (asymmetric outcomes):**',
+        '',
+        'For each injection anchored to a delivery in this focus, there are exactly',
+        'two outcomes -- no third option:',
+        '',
+        '1. **verified** -- the worktree evidence supports the FRT overlay flip.',
+        '   The target UDE is genuinely retired; downstream effects flipped as',
+        '   the injection promised. Call',
+        '   `telora_reality_tree_injection_verify(injectionId, evidence)` so the',
+        '   injection node is marked verified, its targets edges are deleted, and',
+        '   the FRT overlays on targeted UDEs promote to CRT reality.',
+        '',
+        '2. **escalated** -- evidence is absent, ambiguous, or contradicts the',
+        '   expected reality change. File an `injection_unverified` escalation',
+        '   with the specific gap: which UDE did not flip, which evidence was',
+        '   sought and not found, which delivery shipped without realizing the',
+        '   injection. The escalation surfaces to a human; the focus stays at',
+        '   `close_loop` until every anchored injection is verified or escalated.',
+        '',
+        '**Evidence rules.** Evidence MUST be worktree-checkable: files exist,',
+        'tests pass, code matches a pattern, migrations applied, lint clean.',
+        'Evidence is NEVER "the team said they did it" or "an agent narration',
+        'claimed it shipped". If evidence is not in the worktree, it does not',
+        'exist for the purposes of this sweep -- escalate.',
+        '',
+        '**Asymmetric correction.** The control loop moves reality toward intent,',
+        'never the reverse. If a delivery shipped code that does not actually',
+        'flip its target UDE, you ESCALATE (the intent was missed); you do NOT',
+        'silently rewrite the FRT overlay statement to match what shipped. The',
+        'asymmetric bias is the whole reason the bookkeeper exists.',
+        '',
+        '**Other checks the dispatcher delegates to you:**',
+        '',
+        '- `incomplete_planning` -- any deliveries that shipped without anchoring',
+        '  an injection, or any "injection-shaped" residual work the focus did',
+        '  not declare. File one `incomplete_planning` escalation per gap.',
+        '- `tree_drift` -- residual UDEs in the focus tree that no longer relate',
+        '  to the focus statement (the implicit apex). See the drift-check',
+        '  section below for the procedure.',
+        '',
+        'You do not advance the focus to `done` yourself. The daemon advances',
+        '`close_loop -> done` automatically once every anchored injection is',
+        'terminal (verified or escalated) and the residual checks are clean.',
+        '',
+    ].join('\n');
+}
+/**
+ * Build the close_loop drift-check section.
+ *
+ * The close_loop stage agent (the focus "bookkeeper") propagates verified
+ * injection effects back into the CRT and checks the residual tree for drift
+ * against the focus statement. There is no stored apex node in the tree --
+ * `focus.description` is the implicit apex of the reality tree; UDEs
+ * articulate the gap between current reality and that statement.
+ *
+ * This section renders the focus statement verbatim and instructs the
+ * agent to compare residual UDEs against it. It MUST contain both the
+ * focus.description text and the literal token `tree_drift` so the
+ * directive-executor can confirm the close_loop prompt was assembled
+ * correctly (and so reviewers can grep for it).
+ *
+ * If `focusDescription` is null/empty, the section emits a notice that
+ * no apex statement is available and the drift check cannot be performed
+ * -- the agent should escalate.
+ *
+ * See:
+ * - Design principle "Tree-Focus Apex" in memory/design-principles.md
+ * - Wiki page "reality-trees-crt-frt-planning-layer", section
+ *   "Tree-Focus Apex Convention"
+ */
+export function buildCloseLoopDriftCheckSection(focusDescription) {
+    const lines = [];
+    lines.push('### Tree-Focus Apex Drift Check (tree_drift)');
+    lines.push('');
+    lines.push('Telora reality trees do NOT have a stored apex/root node.');
+    lines.push('The focus statement -- `focus.description` -- IS the implicit');
+    lines.push('apex. UDEs articulate the gap between current reality and that');
+    lines.push('statement. Classical Goldratt single-apex CRT structure is not');
+    lines.push('used here; the focus is the alignment target.');
+    lines.push('');
+    lines.push('**Focus statement (apex):**');
+    lines.push('');
+    if (focusDescription && focusDescription.trim()) {
+        lines.push('> ' + focusDescription.trim().split('\n').join('\n> '));
+    }
+    else {
+        lines.push('> _(no focus.description set -- escalate; drift check cannot run)_');
+    }
+    lines.push('');
+    lines.push('**tree_drift check:**');
+    lines.push('');
+    lines.push('1. Enumerate residual UDEs in the CRT (nodeType=undesired_effect,');
+    lines.push('   status=active) for this focus.');
+    lines.push('2. For each UDE, ask: does it describe a gap that the focus');
+    lines.push('   statement above commits to closing?');
+    lines.push('3. UDEs that no longer relate to the focus statement are DRIFT.');
+    lines.push('   Mark them inactive or escalate for human triage -- do not');
+    lines.push('   leave drift in an "active" focus tree.');
+    lines.push('4. UDEs that DO relate but remain unaddressed after all anchored');
+    lines.push('   injections are verified are the unresolved gap -- file them');
+    lines.push('   as escalations so the next focus / human review picks them up.');
+    lines.push('');
+    lines.push('Reminder: there is no apex node to verify or close. Closing the');
+    lines.push('loop means: every anchored injection is terminal, residual UDEs');
+    lines.push('have been classified (resolved / drift / escalated), and the');
+    lines.push('focus statement is the only thing the tree is judged against.');
+    lines.push('');
+    return lines;
+}
+/**
+ * Build the incremental delta message sent when a lineage's session is RESUMED
+ * (INJ-D). A resumed Claude session already holds its role framework, tools,
+ * status rules, and accumulated context -- re-sending the full prompt wastes
+ * tokens and re-anchors. The delta carries only what changed since the last
+ * cycle (the diff) plus the prior findings, deliberately omitting the
+ * role-framework sections.
+ *
+ * Anti-anchoring: for the review lineage the prior findings are framed as "to
+ * VERIFY, not trust" -- the diff and acceptance criteria remain ground truth
+ * each cycle, so a resumed reviewer re-examines rather than rubber-stamping.
+ */
+export function buildResumeDeltaMessage(ctx) {
+    const isReview = ctx.lineage === 'review';
+    const lines = [];
+    lines.push(`## Resuming Your ${isReview ? 'Review' : 'Work'} Session (Incremental Update)`);
+    lines.push('');
+    lines.push(`You are resuming your prior \`${ctx.lineage}\` session on focus "${ctx.focusName}".`);
+    lines.push('Your role, tools, status-update rules, and the context you accumulated in');
+    lines.push('earlier cycles are intact -- this message is ONLY what changed since your last');
+    lines.push('cycle. Do not restart from scratch and do not re-read the full role framework.');
+    lines.push('The diff below and the acceptance criteria (re-read via MCP if needed) are the');
+    lines.push('ground truth for this cycle.');
+    lines.push('');
+    if (ctx.priorFindings.length > 0) {
+        if (isReview) {
+            lines.push('### Prior findings to VERIFY (do not trust)');
+            lines.push('');
+            lines.push('Last cycle you filed the issues below. Do NOT assume they were fixed.');
+            lines.push('For each, check the diff and the current code to confirm it was actually');
+            lines.push('addressed. If it was genuinely resolved, leave it; if not, keep or refile');
+            lines.push('the issue with the specific remaining gap. Your memory is not evidence --');
+            lines.push('the diff is.');
+        }
+        else {
+            lines.push('### Open items from review to address');
+            lines.push('');
+            lines.push('Review filed the issues below against your prior work. Address each as a');
+            lines.push('defect to fix and confirm the fix in the diff. Do not widen scope.');
+        }
+        lines.push('');
+        for (const f of ctx.priorFindings) {
+            lines.push(`- ${f.key}: ${f.title} (${f.status})`);
+        }
+        lines.push('');
+    }
+    lines.push('### What changed since your last cycle (diff against base)');
+    lines.push('');
+    if (ctx.gitDiff.trim()) {
+        lines.push(ctx.gitDiff.trim());
+    }
+    else {
+        lines.push('_The diff resolver returned no content. Run `git diff` against the');
+        lines.push('integration base yourself to see the current state of the worktree._');
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+//# sourceMappingURL=persona-sections.js.map

package/dist/prompt-sections/persona-sections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persona-sections.js","sourceRoot":"","sources":["../../src/prompt-sections/persona-sections.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gCAAgC,CAC9C,oBAA4B;IAE5B,IAAI,oBAAoB,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC;IACzC,OAAO;QACL,+BAA+B;QAC/B,EAAE;QACF,4BAA4B,oBAAoB,6BAA6B;QAC7E,wEAAwE;QACxE,6CAA6C;QAC7C,EAAE;QACF,yEAAyE;QACzE,mBAAmB;QACnB,0EAA0E;QAC1E,8EAA8E;QAC9E,2DAA2D;QAC3D,wEAAwE;QACxE,+DAA+D;QAC/D,EAAE;QACF,uEAAuE;QACvE,qEAAqE;QACrE,EAAE;KACH,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,uBAAuB,CAAC;AAElE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,8BAA8B,CAAC,gBAAwB;IACrE,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,0BAA0B,CAAC;QAAE,OAAO,EAAE,CAAC;IACtE,OAAO;QACL,qBAAqB;QACrB,EAAE;QACF,2HAA2H;QAC3H,EAAE;KACH,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,2BAA2B;IACzC,OAAO;QACL,2BAA2B;QAC3B,EAAE;QACF,4EAA4E;QAC5E,yEAAyE;QACzE,6EAA6E;QAC7E,EAAE;QACF,6DAA6D;QAC7D,uEAAuE;QACvE,6EAA6E;QAC7E,2EAA2E;QAC3E,0EAA0E;QAC1E,EAAE;QACF,0DAA0D;QAC1D,+DAA+D;QAC/D,uDAAuD;QACvD,wEAAwE;QACxE,oFAAoF;QACpF,EAAE;QACF,sDAAsD;QACtD,sEAAsE;QACtE,oEAAoE;QACpE,kEAAkE;QAClE,EAAE;QACF,8EAA8E;QAC9E,4EAA4E;QAC5E,8DAA8D;QAC9D,EAAE;KACH,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,+BAA+B;IAC7C,OAAO;QACL,mCAAmC;QACnC,EAAE;QACF,6EAA6E;QAC7E,2EAA2E;QAC3E,0EAA0E;QAC1E,2EAA2E;QAC3E,QAAQ;QACR,EAAE;QACF,gDAAgD;QAChD,EAAE;QACF,4EAA4E;QAC5E,kCAAkC;QAClC,EAAE;QACF,yEAAyE;QACzE,uEAAuE;QACvE,iCAAiC;QACjC,yEAAyE;QACzE,0EAA0E;QAC1E,8DAA8D;QAC9D,EAAE;QACF,uEAAuE;QACvE,uEAAuE;QACvE,sEAAsE;QACtE,uEAAuE;QACvE,sEAAsE;QACtE,0EAA0E;QAC1E,EAAE;QACF,uEAAuE;QACvE,qEAAqE;QACrE,sEAAsE;QACtE,sEAAsE;QACtE,mDAAmD;QACnD,EAAE;QACF,0EAA0E;QAC1E,sEAAsE;QACtE,uEAAuE;QACvE,uEAAuE;QACvE,4DAA4D;QAC5D,EAAE;QACF,mDAAmD;QACnD,EAAE;QACF,0EAA0E;QAC1E,uEAAuE;QACvE,mEAAmE;QACnE,yEAAyE;QACzE,mEAAmE;QACnE,oCAAoC;QACpC,EAAE;QACF,sEAAsE;QACtE,qEAAqE;QACrE,qEAAqE;QACrE,EAAE;KACH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,+BAA+B,CAC7C,gBAA2C;IAE3C,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,CAAC,IAAI,CAAC,8CAA8C,CAAC,CAAC;IAC3D,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,KAAK,CAAC,IAAI,CAAC,2DAA2D,CAAC,CAAC;IACxE,KAAK,CAAC,IAAI,CAAC,+DAA+D,CAAC,CAAC;IAC5E,KAAK,CAAC,IAAI,CAAC,gEAAgE,CAAC,CAAC;IAC7E,KAAK,CAAC,IAAI,CAAC,gEAAgE,CAAC,CAAC;IAC7E,KAAK,CAAC,IAAI,CAAC,+CAA+C,CAAC,CAAC;IAC5D,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,KAAK,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;IAC1C,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,IAAI,gBAAgB,IAAI,gBAAgB,CAAC,IAAI,EAAE,EAAE,CAAC;QAChD,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,gBAAgB,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACtE,CAAC;SAAM,CAAC;QACN,KAAK,CAAC,IAAI,CAAC,oEAAoE,CAAC,CAAC;IACnF,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,KAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;IACpC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,KAAK,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;IAChF,KAAK,CAAC,IAAI,CAAC,mCAAmC,CAAC,CAAC;IAChD,KAAK,CAAC,IAAI,CAAC,6DAA6D,CAAC,CAAC;IAC1E,KAAK,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;IACrD,KAAK,CAAC,IAAI,CAAC,iEAAiE,CAAC,CAAC;IAC9E,KAAK,CAAC,IAAI,CAAC,8DAA8D,CAAC,CAAC;IAC3E,KAAK,CAAC,IAAI,CAAC,2CAA2C,CAAC,CAAC;IACxD,KAAK,CAAC,IAAI,CAAC,kEAAkE,CAAC,CAAC;IAC/E,KAAK,CAAC,IAAI,CAAC,gEAAgE,CAAC,CAAC;IAC7E,KAAK,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;IAChF,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,KAAK,CAAC,IAAI,CAAC,iEAAiE,CAAC,CAAC;IAC9E,KAAK,CAAC,IAAI,CAAC,iEAAiE,CAAC,CAAC;IAC9E,KAAK,CAAC,IAAI,CAAC,8DAA8D,CAAC,CAAC;IAC3E,KAAK,CAAC,IAAI,CAAC,+DAA+D,CAAC,CAAC;IAC5E,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,OAAO,KAAK,CAAC;AACf,CAAC;AAqBD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB,CAAC,GAAuB;IAC7D,MAAM,QAAQ,GAAG,GAAG,CAAC,OAAO,KAAK,QAAQ,CAAC;IAC1C,MAAM,KAAK,GAAa,EAAE,CAAC;IAE3B,KAAK,CAAC,IAAI,CAAC,oBAAoB,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,+BAA+B,CAAC,CAAC;IAC5F,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,KAAK,CAAC,IAAI,CAAC,iCAAiC,GAAG,CAAC,OAAO,wBAAwB,GAAG,CAAC,SAAS,IAAI,CAAC,CAAC;IAClG,KAAK,CAAC,IAAI,CAAC,2EAA2E,CAAC,CAAC;IACxF,KAAK,CAAC,IAAI,CAAC,gFAAgF,CAAC,CAAC;IAC7F,KAAK,CAAC,IAAI,CAAC,gFAAgF,CAAC,CAAC;IAC7F,KAAK,CAAC,IAAI,CAAC,gFAAgF,CAAC,CAAC;IAC7F,KAAK,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;IAC3C,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAEf,IAAI,GAAG,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACjC,IAAI,QAAQ,EAAE,CAAC;YACb,KAAK,CAAC,IAAI,CAAC,6CAA6C,CAAC,CAAC;YAC1D,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACf,KAAK,CAAC,IAAI,CAAC,uEAAuE,CAAC,CAAC;YACpF,KAAK,CAAC,IAAI,CAAC,0EAA0E,CAAC,CAAC;YACvF,KAAK,CAAC,IAAI,CAAC,2EAA2E,CAAC,CAAC;YACxF,KAAK,CAAC,IAAI,CAAC,2EAA2E,CAAC,CAAC;YACxF,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAC7B,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,IAAI,CAAC,uCAAuC,CAAC,CAAC;YACpD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACf,KAAK,CAAC,IAAI,CAAC,0EAA0E,CAAC,CAAC;YACvF,KAAK,CAAC,IAAI,CAAC,oEAAoE,CAAC,CAAC;QACnF,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACf,KAAK,MAAM,CAAC,IAAI,GAAG,CAAC,aAAa,EAAE,CAAC;YAClC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;QACrD,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,4DAA4D,CAAC,CAAC;IACzE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACf,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACjC,CAAC;SAAM,CAAC;QACN,KAAK,CAAC,IAAI,CAAC,oEAAoE,CAAC,CAAC;QACjF,KAAK,CAAC,IAAI,CAAC,sEAAsE,CAAC,CAAC;IACrF,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAEf,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/dist/prompt-sections/role-sections.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Role-framework section builders: role context, domain boundaries, team-lead
+ * role description, and the read-only audit notice. Extracted from
+ * team-prompt-base.ts.
+ */
+import type { AgentRole } from '../types.js';
+/**
+ * Build the role context section from the agent role's system prompt template.
+ */
+export declare function buildRoleSection(role: AgentRole): string[];
+/**
+ * Build the domain boundaries section from allowed file patterns.
+ */
+export declare function buildDomainBoundariesSection(role: AgentRole): string[];
+/**
+ * Build the team lead role description section.
+ */
+export declare function buildTeamLeadRoleSection(engineId?: string): string[];
+/**
+ * Build the read-only audit mode notice section.
+ * Returns empty array if not in read-only mode.
+ */
+export declare function buildReadOnlyAuditSection(readOnly?: boolean): string[];
+//# sourceMappingURL=role-sections.d.ts.map

package/dist/prompt-sections/role-sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role-sections.d.ts","sourceRoot":"","sources":["../../src/prompt-sections/role-sections.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,EAAE,CAO1D;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,EAAE,CAWtE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBpE;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAkBtE"}

package/dist/prompt-sections/role-sections.js

@@ -0,0 +1,78 @@
+/**
+ * Role-framework section builders: role context, domain boundaries, team-lead
+ * role description, and the read-only audit notice. Extracted from
+ * team-prompt-base.ts.
+ */
+import { orchestrationVocabulary } from './shared.js';
+/**
+ * Build the role context section from the agent role's system prompt template.
+ */
+export function buildRoleSection(role) {
+    const lines = [];
+    if (role.system_prompt_template) {
+        lines.push(role.system_prompt_template);
+        lines.push('');
+    }
+    return lines;
+}
+/**
+ * Build the domain boundaries section from allowed file patterns.
+ */
+export function buildDomainBoundariesSection(role) {
+    const lines = [];
+    if (role.allowed_file_patterns.length > 0) {
+        lines.push('## Domain Boundaries');
+        lines.push('You are authorized to work on files matching these patterns:');
+        for (const pattern of role.allowed_file_patterns) {
+            lines.push(`- ${pattern}`);
+        }
+        lines.push('');
+    }
+    return lines;
+}
+/**
+ * Build the team lead role description section.
+ */
+export function buildTeamLeadRoleSection(engineId) {
+    const vocab = orchestrationVocabulary(engineId);
+    return [
+        '## Your Role: Focus Team Lead',
+        '',
+        'You are the team lead for this focus. You coordinate all deliveries',
+        'and their issues, spawning workers for parallel execution where possible.',
+        '',
+        '**Core responsibilities:**',
+        '1. Read all deliveries and issues for the focus',
+        '2. Build a task execution plan respecting delivery priority and file overlap',
+        vocab.spawnStep,
+        '4. Track issue completion and advance delivery stages',
+        '5. Poll for new deliveries added during execution',
+        '6. Handle errors, escalate blockers, and report progress',
+        '',
+    ];
+}
+/**
+ * Build the read-only audit mode notice section.
+ * Returns empty array if not in read-only mode.
+ */
+export function buildReadOnlyAuditSection(readOnly) {
+    if (!readOnly)
+        return [];
+    return [
+        '## READ-ONLY AUDIT MODE',
+        '',
+        'This is a read-only audit session. The filesystem allows reading but commits',
+        'are blocked by a pre-commit hook. Your job is DISCOVERY ONLY:',
+        '',
+        '- Identify and document problems by creating issues via MCP tools',
+        '- Create exactly ONE remediation delivery per audit delivery via',
+        '  telora_product_delivery_create (execution_status: "planning")',
+        '- Use Context Groups to organize findings within remediation deliveries',
+        '- Do NOT modify, fix, or commit any code changes',
+        '- Do NOT attempt to bypass the pre-commit hook',
+        '',
+        'If you try to commit, the hook will reject it with a reminder of these rules.',
+        '',
+    ];
+}
+//# sourceMappingURL=role-sections.js.map

package/dist/prompt-sections/role-sections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"role-sections.js","sourceRoot":"","sources":["../../src/prompt-sections/role-sections.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAEtD;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAe;IAC9C,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAChC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QACxC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,4BAA4B,CAAC,IAAe;IAC1D,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,IAAI,CAAC,qBAAqB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1C,KAAK,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QACnC,KAAK,CAAC,IAAI,CAAC,8DAA8D,CAAC,CAAC;QAC3E,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YACjD,KAAK,CAAC,IAAI,CAAC,KAAK,OAAO,EAAE,CAAC,CAAC;QAC7B,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,wBAAwB,CAAC,QAAiB;IACxD,MAAM,KAAK,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IAChD,OAAO;QACL,+BAA+B;QAC/B,EAAE;QACF,qEAAqE;QACrE,2EAA2E;QAC3E,EAAE;QACF,4BAA4B;QAC5B,iDAAiD;QACjD,8EAA8E;QAC9E,KAAK,CAAC,SAAS;QACf,uDAAuD;QACvD,mDAAmD;QACnD,0DAA0D;QAC1D,EAAE;KACH,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,yBAAyB,CAAC,QAAkB;IAC1D,IAAI,CAAC,QAAQ;QAAE,OAAO,EAAE,CAAC;IACzB,OAAO;QACL,yBAAyB;QACzB,EAAE;QACF,8EAA8E;QAC9E,+DAA+D;QAC/D,EAAE;QACF,mEAAmE;QACnE,kEAAkE;QAClE,iEAAiE;QACjE,yEAAyE;QACzE,kDAAkD;QAClD,gDAAgD;QAChD,EAAE;QACF,+EAA+E;QAC/E,EAAE;KACH,CAAC;AACJ,CAAC"}

package/dist/prompt-sections/shared.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Shared types and private helpers for the focus team prompt section builders.
+ *
+ * Extracted from team-prompt-base.ts. Holds the prompt-context interfaces and
+ * the engine-specific orchestration vocabulary helper used by 2+ section
+ * modules, so the section modules and the team-prompt-base aggregator import
+ * from one place (avoids circular imports).
+ */
+import type { FocusDeliveryInfo, FocusIssueInfo, FocusExecutionConfig, PipelineConfig } from '../types.js';
+import type { ProductContextDoc } from '../queries/focuses.js';
+export interface DeploymentProfileSnapshotContext {
+    name: string;
+    inceptionPrompt: string | null;
+    guidelines: string | null;
+}
+export interface FocusTeamPromptContext {
+    focusId: string;
+    focusName: string;
+    organizationId: string;
+    productId: string;
+    deliveries: FocusDeliveryInfo[];
+    issues: FocusIssueInfo[];
+    executionConfig: FocusExecutionConfig;
+    pipelineConfig: PipelineConfig | null;
+    productContextDocs?: ProductContextDoc[];
+    deploymentProfileSnapshot?: DeploymentProfileSnapshotContext | null;
+    readOnly?: boolean;
+    loopContext?: string;
+    /**
+     * Number of open review-filed issues across all deliveries on this
+     * focus. When > 0, the team prompt includes a remediation directive
+     * orienting the team to "fix flagged defects, do not expand scope".
+     */
+    reviewFiledOpenCount?: number;
+    /**
+     * Focus.description -- the focus statement that serves as the implicit
+     * apex of the reality tree. Surfaced to the close_loop stage agent as
+     * the alignment target for the tree-drift check. See the design
+     * principle "Tree-Focus Apex" and the wiki page
+     * "reality-trees-crt-frt-planning-layer".
+     */
+    focusDescription?: string | null;
+    /**
+     * Resolved engine backend id ('claude' | 'codex' | ...). Selects the
+     * engine-specific orchestration vocabulary in the lead prompt (how the lead
+     * spawns workers). Defaults to 'claude' when absent.
+     */
+    engineId?: string;
+}
+/**
+ * The lead spawns workers differently per engine. Portable task content (what
+ * to build, status protocol, MCP rules) is identical; only the orchestration
+ * verbs differ. Codex also needs an explicit caveat about clean subagent
+ * spawns (the spike hit a router error when a full-history fork carried
+ * agent_type/model/reasoning_effort).
+ */
+export interface OrchestrationVocabulary {
+    /** One-line description of how to spawn parallel work (role section step 3). */
+    spawnStep: string;
+    /** Opening of the Phase 2 worker-management section. */
+    workerMechanism: string;
+    /** Optional extra caveat lines appended to worker-management (Codex). */
+    caveat: string[];
+}
+export declare function orchestrationVocabulary(engineId: string | undefined): OrchestrationVocabulary;
+//# sourceMappingURL=shared.d.ts.map

package/dist/prompt-sections/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/prompt-sections/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,cAAc,EACf,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,MAAM,WAAW,gCAAgC;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,iBAAiB,EAAE,CAAC;IAChC,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,eAAe,EAAE,oBAAoB,CAAC;IACtC,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,kBAAkB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACzC,yBAAyB,CAAC,EAAE,gCAAgC,GAAG,IAAI,CAAC;IACpE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAMD;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,gFAAgF;IAChF,SAAS,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,eAAe,EAAE,MAAM,CAAC;IACxB,yEAAyE;IACzE,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,uBAAuB,CAyB7F"}