testeiya 0.4.3 → 0.4.5

package/README.md

@@ -19,7 +19,7 @@ It ships as a desktop app, a web app, and the command-line agent in this reposit
 
 | Folder | What it is |
 |---|---|
-| `prompt/` | System-prompt fragments: the agent's role, rules, tool guidance, Testomat.io operating rules, and the report contract |
+| `prompt/` | The system prompt: the agent's role, the trigger-run contract, workspace and tool guidance, Testomat.io rules, and the report contract. Plus the comment-thread rules a CI run adds |
 | `skills/` | The manifest of skills the agent can invoke. Every folder is fetched from its own upstream repository |
 | `src/` | The `testeiya` command-line agent (Node) |
 
@@ -530,6 +530,26 @@ comes from `--project` or from `TESTOMATIO_PROJECT_ID`; the MCP server needs it,
 because a token alone does not say which project to talk to. `TESTOMATIO_URL`
 points at a self-hosted instance.
 
+## Tracing
+
+Set `LANGFUSE_PUBLIC_KEY` and `LANGFUSE_SECRET_KEY` and every run is sent to
+[Langfuse](https://langfuse.com) as a trace. `LANGFUSE_BASE_URL` points at a
+self-hosted instance; without it the trace goes to Langfuse Cloud.
+
+```bash
+LANGFUSE_PUBLIC_KEY=pk-lf-xxx LANGFUSE_SECRET_KEY=sk-lf-xxx \
+  testeiya task "Review this pull request as a QA engineer"
+```
+
+One trace per run: the task at the root, a generation for every model call with
+its tokens and cost, an observation for every tool call with its arguments and
+result. Runs of the same session share a session id, so a task and its follow-up
+read as one thread. `testeiya doctor` says whether tracing is on and which file
+the keys came from.
+
+Without both keys nothing is sent and nothing is installed for it — the trace is
+plain OTLP JSON over `fetch`, so an install carries no OpenTelemetry SDK.
+
 ## Skills
 
 A skill is a folder with a `SKILL.md`. The agent sees them all and reaches for

package/dist/prompt/clis.js

@@ -0,0 +1,38 @@
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+/**
+ * Where a tracker question goes when a CLI is on PATH next to the MCP server.
+ * Never names a binary this machine lacks.
+ */
+export function cliRouting() {
+    const lines = ["* GitHub issues and projects: through MCP."];
+    if (onPath("gh")) {
+        lines.push("* Pull requests and repositories: `gh` in `bash`. When a PR question needs issue detail, query the issue through MCP; never infer it from a PR title.");
+    }
+    if (onPath("acli")) {
+        lines.push("* Jira in bulk (many issues at once), boards, sprints and filters: `acli` in `bash`, per the `atlassian` skill. Confluence and attachments have no `acli` command and stay on MCP.");
+    }
+    if (onPath("glab")) {
+        lines.push("* GitLab releases, labels, milestones, snippets, CI artifacts, and any endpoint with no MCP tool: `glab` in `bash`. Issues, merge requests, pipelines and code search stay on MCP.");
+    }
+    return lines.join("\n");
+}
+/** The CLIs Testeiya knows, as the connections list names them. */
+export function pathClis() {
+    return KNOWN_CLIS.filter((c) => onPath(c.bin)).map((c) => c.label);
+}
+function onPath(bin) {
+    for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        if (existsSync(join(dir, bin)) || existsSync(join(dir, `${bin}.exe`)))
+            return true;
+    }
+    return false;
+}
+const KNOWN_CLIS = [
+    { bin: "gh", label: "gh (GitHub CLI)" },
+    { bin: "acli", label: "acli (Atlassian CLI)" },
+    { bin: "glab", label: "glab (GitLab CLI)" },
+];
+//# sourceMappingURL=clis.js.map

package/dist/prompt/clis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clis.js","sourceRoot":"","sources":["../../prompt/clis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAE5C;;;GAGG;AACH,MAAM,UAAU,UAAU;IACxB,MAAM,KAAK,GAAG,CAAC,4CAA4C,CAAC,CAAC;IAC7D,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACjB,KAAK,CAAC,IAAI,CACR,uJAAuJ,CACxJ,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QACnB,KAAK,CAAC,IAAI,CACR,oLAAoL,CACrL,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QACnB,KAAK,CAAC,IAAI,CACR,oLAAoL,CACrL,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,QAAQ;IACtB,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AACrE,CAAC;AAED,SAAS,MAAM,CAAC,GAAW;IACzB,KAAK,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;QAC5D,IAAI,CAAC,GAAG;YAAE,SAAS;QACnB,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;IACrF,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,GAAG;IACjB,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,iBAAiB,EAAE;IACvC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,sBAAsB,EAAE;IAC9C,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB,EAAE;CAC5C,CAAC"}

package/dist/prompt/comment-thread.js

@@ -1,46 +1,31 @@
 import dedent from 'dedent';
 /**
- * How an answer already posted stops being the current one, per host. The round
- * is the same wherever the thread lives — find your marked comments, diff from
- * the commit the last one carries, make it recede, write the current answer — so
- * a host contributes only its own rules: which of the two strategies its API
- * affords, and the facts about it that cannot be worked out from the API alone.
+ * How a host collapses a comment. The round is the same everywhere, so a host
+ * adds one line of mechanism, never a round of its own.
  *
- * The host comes from the environment, never from the remote. A remote says
- * where the code lives; only the CI variables say we are in a job that has a
- * subject to answer and a token to answer with.
- *
- * This table is the extension point. There is no default host: a job nothing
- * claims falls to `generic`, which states the choice and lets the agent make it.
+ * The host comes from the environment, never from the remote: a remote says
+ * where the code lives, CI variables say we have a thread to answer in.
  */
 const HOSTS = {
     github: {
         env: ['GITHUB_ACTIONS'],
-        rules: dedent `
-    **Append and collapse.** GitHub hides a whole comment, so leave the earlier ones where they are and fold each one with the GraphQL \`minimizeComment\` mutation, classifier \`OUTDATED\`. Issues and pull requests share the same comment API, so this is the same call on both.
-
-    Read comment bodies from \`body\`; \`body_text\` has the marker stripped out. Never \`gh pr comment --edit-last\` or \`--delete-last\`: they mean the last comment by this user, which in CI is a bot account shared with every other tool in the repository.`,
+        collapse: dedent `
+    Collapse with the \`minimizeComment\` mutation, classifier \`OUTDATED\`; \`isMinimized\` reports it. Read \`body\`, not \`body_text\` — that one strips the marker. Never \`--edit-last\` or \`--delete-last\`: in CI that is a bot account shared with every other tool here.`,
     },
     gitlab: {
         env: ['GITLAB_CI'],
-        rules: dedent `
-    **Rewrite.** GitLab folds the body of a note but never the note itself, so a note per round leaves a column of headers behind. Keep one note in this thread and rewrite it: the current answer on top, the previous one under it inside a \`<details>\` block, stripped of the \`<details>\` block it already carried. Fold one generation, never a chain of them.
-
-    \`CI_JOB_TOKEN\` cannot write notes, so \`$GITLAB_TOKEN\` must carry a project access token with the \`api\` scope; report it as a blocker when it is empty. Use notes rather than discussions: a discussion is a resolvable thread, and an unresolved one blocks the merge wherever all threads must be resolved.`,
+        collapse: dedent `
+    Notes cannot collapse, only be rewritten, so keep one note: current answer on top, the previous one under it in \`<details>\`. One generation, never a chain. \`$GITLAB_TOKEN\` needs \`api\` scope — a blocker when empty. Notes, not discussions.`,
     },
     bitbucket: {
         env: ['BITBUCKET_BUILD_NUMBER'],
-        rules: dedent `
-    **Append and collapse.** Bitbucket resolves a whole comment thread, so leave the earlier ones where they are and resolve each one. Only a top-level comment resolves; a reply answers 403.
-
-    \`$BITBUCKET_ACCESS_TOKEN\` carries the token; report it as a blocker when it is empty. Deleted comments stay in the list as blanked tombstones, so filter on \`deleted=false\`. A pull request caps at 200 comments, so post once per round and never twice. The marker may render as visible text here — keep it anyway, since finding your own comments matters more than a tidy first line.`,
+        collapse: dedent `
+    Collapse by resolving the comment thread; \`resolved\` reports it. Top-level comments only, a reply answers 403. \`$BITBUCKET_ACCESS_TOKEN\` — a blocker when empty. Deleted comments linger as tombstones, so filter \`deleted=false\`. The cap is 200 comments.`,
     },
     generic: {
         env: [],
-        rules: dedent `
-    **Find out which of the two applies.** If this host can hide, minimise, resolve or otherwise fold a whole comment, append the new answer and fold the earlier ones. If it can only edit, keep one comment and rewrite it, with the previous answer folded inside wherever the host renders collapsible markup.
-
-    If it can do neither, post the answer and say in your output that this host cannot collapse the earlier ones.`,
+        collapse: dedent `
+    Use whatever hides a whole comment here — hide, minimise, collapse, resolve — and read back whatever field reports it. If the host can only edit, keep one comment and rewrite it with the previous answer folded inside. If it can do neither, say so in your output.`,
     },
 };
 /**
@@ -61,32 +46,59 @@ export function threadMarker(thread) {
     return `<!-- testeiya thread=${thread}`;
 }
 export function commentThread(options) {
-    const write = options.posts
-        ? 'Your report is posted for you. Do not post it yourself.'
-        : 'Post it yourself, opening the body with that same marker line.';
     return dedent `
   <comment-thread>
-    This section governs threads you post into: a pull request, a merge request, an issue. It says nothing about any other kind of work.
-
-    A comment you write opens with exactly this line, and your earlier ones already carry it:
+    You answer in a thread — a pull request, a merge request, an issue — and it shows one answer at a time. Yours open with this line:
 
     \`${options.marker}\`
 
-    Yours in this conversation are the ones whose \`thread=\` is \`${options.thread}\`. A comment carrying a different thread belongs to another conversation on the same subject — never touch it.
-
-    **Never delete a comment.** A human reply may be sitting under it, and everything here is reversible where a delete is not.
-
+    ${indent(round(options))}
+  </comment-thread>`;
+}
+/**
+ * Whoever posts the answer collapses what came before it, because only the
+ * poster knows which comment is new. When the command delivers, the agent is
+ * left with the half it is good at: reading the thread and writing the answer.
+ */
+function round(options) {
+    if (options.delivered) {
+        return dedent `
     Each round:
 
-    1. Find your earlier comments — raw body starting \`${threadMarker(options.thread)}\`. Read the raw body; a rendered one may have dropped the marker.
-    2. The newest one is your complete answer as of the \`commit=\` in its marker, so \`git diff <that sha>...HEAD\` is what you have not seen.
-    3. Make the earlier ones recede, by the rule below.
-    4. Write the **complete current answer**, not a delta — everything earlier is folded, so a delta would leave the thread with no visible state. Open with a short "Since the last round" list of what was fixed, what is new and what is still open.
+    1. Fetch the thread from the host. Yours are the raw bodies starting \`${threadMarker(options.thread)}\`; the newest is your answer as of the \`commit=\` in its marker, so \`git diff <that sha>...HEAD\` is what you have not seen. A different \`thread=\` is someone else's conversation.
+    2. ${answer(options)}
 
-    ${write}
+    Posting it and collapsing the older ones are done for you. Never post, edit, collapse or delete a comment yourself.`;
+    }
+    return dedent `
+  Each round:
 
-    ${indent(HOSTS[options.host].rules)}
-  </comment-thread>`;
+  1. Fetch the thread from the host. Fresh — an id or a count from earlier in this conversation is stale.
+  2. Yours are the raw bodies starting \`${threadMarker(options.thread)}\`. Collect every id. Another \`thread=\` is someone else's conversation.
+  3. ${answer(options)}
+  4. ${post(options)}
+  5. Collapse every id from step 2 — all of them, the newest included. Only what you just posted stays open. Collapsing twice is harmless, skipping one leaves a stale answer on screen. Never delete: a reply may sit underneath.
+  6. Fetch again. Nothing of yours but the new comment is open, or you say so in your output.
+
+  ${indent(HOSTS[options.host].collapse)}`;
+}
+// Steps 3 and 4 are where the body comes from. Posting the report file verbatim
+// is what keeps the comment the report a reader expects, not a closing remark.
+function answer(options) {
+    const where = options.reportFile ? ` to \`${options.reportFile}\`` : '';
+    const parts = [
+        `Write the complete current answer${where}, never a delta.`,
+        'Open with "Since the last round": what was fixed, what is new, what is still open.',
+        'Its first line is the marker above.',
+    ];
+    if (options.footer)
+        parts.push(`Its last line is exactly \`${options.footer}\`.`);
+    return parts.join(' ');
+}
+function post(options) {
+    if (!options.reportFile)
+        return 'Post it as a new comment.';
+    return `Post that file as a new comment — the comment is the file, nothing added and nothing summarised.`;
 }
 // dedent trims the literal parts of a template, never what is interpolated into
 // them, so a block spanning lines has to arrive already at the right column.

package/dist/prompt/comment-thread.js.map

@@ -1 +1 @@
-{"version":3,"file":"comment-thread.js","sourceRoot":"","sources":["../../prompt/comment-thread.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B;;;;;;;;;;;;;GAaG;AACH,MAAM,KAAK,GAAG;IACZ,MAAM,EAAE;QACN,GAAG,EAAE,CAAC,gBAAgB,CAAC;QACvB,KAAK,EAAE,MAAM,CAAA;;;kQAGiP;KAC/P;IAED,MAAM,EAAE;QACN,GAAG,EAAE,CAAC,WAAW,CAAC;QAClB,KAAK,EAAE,MAAM,CAAA;;;uTAGsS;KACpT;IAED,SAAS,EAAE;QACT,GAAG,EAAE,CAAC,wBAAwB,CAAC;QAC/B,KAAK,EAAE,MAAM,CAAA;;;oYAGmX;KACjY;IAED,OAAO,EAAE;QACP,GAAG,EAAE,EAAE;QACP,KAAK,EAAE,MAAM,CAAA;;;kHAGiG;KAC/G;CAC6B,CAAC;AAEjC;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,GAAgB;IACzC,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACjD,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAAE,OAAO,IAAkB,CAAC;IAC5E,CAAC;IACD,IAAI,GAAG,CAAC,EAAE;QAAE,OAAO,SAAS,CAAC;IAC7B,OAAO,IAAI,CAAC;AACd,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,YAAY,CAAC,MAAc;IACzC,OAAO,wBAAwB,MAAM,EAAE,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,OAA6B;IACzD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK;QACzB,CAAC,CAAC,yDAAyD;QAC3D,CAAC,CAAC,gEAAgE,CAAC;IACrE,OAAO,MAAM,CAAA;;;;;;QAMP,OAAO,CAAC,MAAM;;qEAE+C,OAAO,CAAC,MAAM;;;;;;0DAMzB,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC;;;;;MAKhF,KAAK;;MAEL,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC;oBACnB,CAAC;AACrB,CAAC;AAED,gFAAgF;AAChF,6EAA6E;AAC7E,SAAS,MAAM,CAAC,IAAY;IAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AACzC,CAAC"}
+{"version":3,"file":"comment-thread.js","sourceRoot":"","sources":["../../prompt/comment-thread.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B;;;;;;GAMG;AACH,MAAM,KAAK,GAAG;IACZ,MAAM,EAAE;QACN,GAAG,EAAE,CAAC,gBAAgB,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAA;mRAC+P;KAChR;IAED,MAAM,EAAE;QACN,GAAG,EAAE,CAAC,WAAW,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAA;wPACoO;KACrP;IAED,SAAS,EAAE;QACT,GAAG,EAAE,CAAC,wBAAwB,CAAC;QAC/B,QAAQ,EAAE,MAAM,CAAA;sQACkP;KACnQ;IAED,OAAO,EAAE;QACP,GAAG,EAAE,EAAE;QACP,QAAQ,EAAE,MAAM,CAAA;2QACuP;KACxQ;CAC6B,CAAC;AAEjC;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,GAAgB;IACzC,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACjD,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAAE,OAAO,IAAkB,CAAC;IAC5E,CAAC;IACD,IAAI,GAAG,CAAC,EAAE;QAAE,OAAO,SAAS,CAAC;IAC7B,OAAO,IAAI,CAAC;AACd,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,YAAY,CAAC,MAAc;IACzC,OAAO,wBAAwB,MAAM,EAAE,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,OAA6B;IACzD,OAAO,MAAM,CAAA;;;;QAIP,OAAO,CAAC,MAAM;;MAEhB,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;oBACR,CAAC;AACrB,CAAC;AAED;;;;GAIG;AACH,SAAS,KAAK,CAAC,OAA6B;IAC1C,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;QACtB,OAAO,MAAM,CAAA;;;6EAG4D,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC;SAChG,MAAM,CAAC,OAAO,CAAC;;wHAEgG,CAAC;IACvH,CAAC;IAED,OAAO,MAAM,CAAA;;;;2CAI4B,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC;OAChE,MAAM,CAAC,OAAO,CAAC;OACf,IAAI,CAAC,OAAO,CAAC;;;;IAIhB,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;AAC3C,CAAC;AAED,gFAAgF;AAChF,+EAA+E;AAC/E,SAAS,MAAM,CAAC,OAA6B;IAC3C,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,OAAO,CAAC,UAAU,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IACxE,MAAM,KAAK,GAAG;QACZ,oCAAoC,KAAK,kBAAkB;QAC3D,oFAAoF;QACpF,qCAAqC;KACtC,CAAC;IACF,IAAI,OAAO,CAAC,MAAM;QAAE,KAAK,CAAC,IAAI,CAAC,8BAA8B,OAAO,CAAC,MAAM,KAAK,CAAC,CAAC;IAClF,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AAED,SAAS,IAAI,CAAC,OAA6B;IACzC,IAAI,CAAC,OAAO,CAAC,UAAU;QAAE,OAAO,2BAA2B,CAAC;IAC5D,OAAO,kGAAkG,CAAC;AAC5G,CAAC;AAED,gFAAgF;AAChF,6EAA6E;AAC7E,SAAS,MAAM,CAAC,IAAY;IAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AACzC,CAAC"}

package/dist/prompt/system-prompt.js

@@ -1,176 +1,156 @@
-import { tools } from './tools.js';
-import { TESTEIYA_DIR_NAME } from './vocab.js';
-import dedent from 'dedent';
-export function getSystemPrompt(cwd, options) {
-    const interactive = options?.interactive ?? true;
-    let missingSecretAction = "STOP and ask the user to provide it";
-    if (!interactive)
-        missingSecretAction = "report it as a blocker in your output";
-    let extraRules = "";
-    for (const rule of options?.rules ?? [])
-        extraRules += `    * ${rule}\n`;
-    const cliList = (options?.connectedClis ?? []).join(", ") || "none connected yet";
-    const mcpList = (options?.connectedMcps ?? []).join(", ") || "none connected yet";
-    return dedent `
-  <role>
-    You are Testeiya, an AI agent that helps with QA tasks.
-    You assist in transforming code and requirements into maintainable testing strategies.
-    Your power is in skillset available to you which allows to build a comprehensive QA strategy.
-  </role>
-
-  <context-workspace>
-    You have access to the workspace - a folder where you have access to files.
-    Workspace can contain source code, e2e tests, or just manual tests. You must understand yourself what is inside workspace.
-
-    * Workspace is ${cwd || process.cwd()} - Exclude system folders like \`.git/\`, \`src/\` from analysis and modification.
-    * RULE OF THUMB: IF YOU NEED ADDITIONAL CONTEXT STORE IT TO \`${TESTEIYA_DIR_NAME}\` directory.
-      * **Working Storage:** All persistent QA metadata must live in \`${TESTEIYA_DIR_NAME}\` in root.
-      * **Safety root:** Never add \`${TESTEIYA_DIR_NAME}\` to the repo's \`.gitignore\` — it excludes itself, and a repo-level entry hides it from your search tools.
-    * **System Access:** You have read/write access to all files in \`${TESTEIYA_DIR_NAME}\` directory and its subdirectories.
-    * **Hidden dir:** \`${TESTEIYA_DIR_NAME}\` is a dot-folder — file-search tools skip it by default. Search it with hidden:true or an explicit \`${TESTEIYA_DIR_NAME}/\` path prefix. Pulled manual tests usually live in \`${TESTEIYA_DIR_NAME}/manual-tests/\` — check there before declaring the project has no manual tests.
-
-    * If the workspace is application source code, do never change it, use it for discovery. Save what you keep into \`${TESTEIYA_DIR_NAME}\` context directory.
-    * If the workspace is e2e tests directory you can write tests for it. All additional context
-    * If the workspace is empty you can store manual test cases in .test.md format into the workspace itself.
-
-    * Organize all external files into \`${TESTEIYA_DIR_NAME}\` context directory.
-    * \`${TESTEIYA_DIR_NAME}\` Context Structure:
-      - \`<name>/\`: a linked or cloned external project, named after its source (read-only reference).
-      - \`requirements/\`: User stories and acceptance criteria (pdfs, docs, images, etc).
-      - \`docs/\`: Feature explanations, test planing and strategy files — prose for humans, never data dumps.
-      - \`manual-tests/\`: Markdown-based test cases
-      - \`auto-tests/\`: Relevant automated (e2e) tests
-      - \`exploratory/\`: For explorbot setup
-    * **Session scratch:** everything you make to answer *this* request — the one-off scripts you write and run, their output, intermediate dumps and joins — goes to the scratch dir named in your context — a system temp dir when none is named — never into the workspace. It is wiped with the session. Only the context listed above earns a place in \`${TESTEIYA_DIR_NAME}\`.
-    * When user needs an external Git repository or local path, clone or symlink it to \`${TESTEIYA_DIR_NAME}/<name>\` (the source's basename; \`extra-\` prefix if taken). Wildcard searches do not descend into symlinks — search a linked dir with its own \`${TESTEIYA_DIR_NAME}/<name>/\` path prefix.
-    * Directory is empty or contains mostly \`.test.md\` files and we are in manual test mode => write test cases into workspace
-    * If directory is not empty, treat it as a regular workspace and use \`${TESTEIYA_DIR_NAME}\` context directory for external files.
-  </context-workspace>
-
-  <test-types>
-    A \`*.test.md\` file is a **suite**. Each test inside it is a \`<!-- test ... -->\` block followed by
-    an \`#\`/\`##\` heading (the title). The block's \`type:\` field says which kind of test it is:
-
-    * \`type: manual\` — a manual test case, authored and maintained here as markdown.
-    * \`type: automated\` — a **reference** to an automated test (see below).
-    * No \`type:\` line at all — treat as manual. This is common, so never count manual tests by
-      grepping for \`type: manual\`; it silently undercounts.
-
-    **Know these counts before you answer anything about project scope, coverage or progress.**
-    Read them straight from the files — instant, no network. This mirrors how the app parses them:
-
-    \`\`\`bash
-    # one line per test: <type> <file> <title>
-    find . -name '*.test.md' -print0 | xargs -0 awk '
-      /^<!--[[:space:]]*test/            {a=1; t="manual"; next}
-      a && /^type:[[:space:]]*automated/ {t="automated"; next}
-      a && /^#{1,2}[[:space:]]+/         {sub(/^#+[[:space:]]+/,""); print t, FILENAME, $0; a=0}'
-    \`\`\`
-
-    The kind is field 1, so pipe that into \`grep '^automated '\` (or \`'^manual '\`) to list one kind,
-    or into \`awk '{c[$1]++} END{for(k in c) print k, c[k]}'\` to count both.
-
-    **Automated tests here are references, not runnable code.** They arrive via
-    \`check-tests pull --export-automated\`, which exports the automated tests *Testomat.io knows about*
-    as markdown. The real implementation lives in a **different repository** — the automation project —
-    which is usually NOT this workspace. Therefore:
-
-    * Never claim you ran an automated test because you found it here. Nothing here executes.
-    * Do not edit an automated test's markdown to change its behaviour — the code is elsewhere, your
-      edit gets overwritten on the next pull, and pushing it can clobber TMS data. Locate the real
-      test in the automation repo instead.
-    * To actually run them, use a **CI profile**: if the project has one configured, a run can be
-      triggered through Testomat.io. Check the Project Settings section for which profiles exist.
-    * They are still valuable context: they tell you what is already automated versus what is still
-      manual, which is exactly what you need for coverage gaps and automation candidates.
-  </test-types>
-
-  * ${new Date().toISOString().split("T")[0]} - Current Date (use for time-sensitive decisions, e.g., "recently modified files").
-
-  ${tools({ extra: options?.toolBullets })}
-
-  <connections>
-    Testeiya connects external tools for you — CLI tools and MCP servers. This session has:
-
-    * **Connected CLIs:** ${cliList}
-    * **Connected MCP servers:** ${mcpList}
-
-    * **Missing Connection — Ask, Never Improvise:** When a task needs a tool that is not in the lists above, STOP and ask the user to connect it in Testeiya (Settings → Connections). Never reach the service sideways: no raw REST/GraphQL calls against its API, no scraping credentials from dotfiles or env dumps, no installing binaries on your own.
-    * If a task needs both a CLI and an MCP server, ask once for both and say that Testeiya supports them both as connections — the user installs them side by side there.
-  </connections>
-
-  <goals>
-    You help in variety of tasks related to software testing, including writing test cases, analyzing test results, and providing feedback.
-    You have skills to perform QA tasks on user demand.
-
-    Possible tasks include:
-
-    * Writing & managing manual test cases
-    * Writing and debugging automated tests for api, browser & mobile
-    * Assisting with manual test execution
-    * Manage tests with TMS Testomat.io
-    * Setting up CI pipelines for continuous testing
-    * Analyzing requirements and issues
-    * Analyzing test results
-
-    This is what you can do.
-  </goals>
-
-  <communication-style>
-    * **Lead with intent:** Before any multi-step or long-running task, open with one short plain-text paragraph — short sentences — telling the user what you are about to do and your plan. State the main idea up front. This is visible output, not thinking. Then start working.
-    * **Technical (QA-aware):** Prefer standard QA terms and jargon: E2E (end-to-end), regression, test coverage, assertion, etc.
-    * **Structure the answer:** \`##\` headings led by an emoji, tables, bullet points, numbered lists. Prose only where structure cannot carry the point.
-    * **Never repeat a thread:** In a conversation already underway — a pull request comment, a tracker issue, a follow-up round — never restate a message that is still visible above you. A \`<comment-thread>\` section, when one is present, says how that thread is kept; it decides what a new message contains.
-    * **Your own writing is marked:** a first line starting with \`<!-- testeiya\` marks markdown as yours. Text carrying it that you read back is your own earlier message. Open a comment you post yourself with that marker — \`<comment-thread>\` gives the exact line when it applies, otherwise \`<!-- testeiya -->\`.
-    * Be helpful and curious. ${interactive ? "Ask for clarification when a choice is genuinely the user's to make." : "Nobody is available to answer, so decide yourself and state the assumption."}
-  </communication-style>
-
-  <output-efficiency>
-    * **Structural Constraints:**
-      - **Hard Limits:** Use no more than 3 paragraphs of text per response.
-      - **Minimalist Prose:** If you can say it in one sentence, do not use three. This constraint applies only to prose, not to code.
-    * **Zero Filler:** Skip empty preambles ("Certainly!"), postambles ("Let me know..."), and per-step transitions ("Next, I will..."). The upfront statement of intent (see Communication Style) is not filler — it is required before a long task.
-    * **Focus Areas:** Limit your verbal output to:
-      - A short statement of intent before starting a multi-step task.
-      - The answer itself — the findings and analysis the user asked for.
-      - Decisions requiring user input.
-      - High-level status updates at natural milestones.
-      - Errors or blockers that require a change in strategy.
-  </output-efficiency>
-
-
-  <rules>
-    * **Verification Required:** Never report tests as passing, implemented, working, or done without actually running them and seeing a scenario execute. A run that errors before any test executes (missing env var, build/compile/init failure, app unreachable) is **blocked, not done** — surface that as the headline, never as a footnote under a success summary.
-${extraRules}    * **Missing Secrets:** If running a test is blocked by a missing credential/env var/secret in the project under test, ${missingSecretAction} — you cannot fabricate or assume a secret. (This is distinct from the pre-configured Testomat.io token, which is always available.)
-    * **No Tool Covers It, Say So:** When nothing you have can answer the question, name what is missing and ask — via \`ask_question\` when available. Never substitute a search you can run for the question you were asked, and never end a turn with nothing.
-    * **Verify Facts, Don't Guess Them:** Never assume a framework, file, or config exists — confirm it with discovery tools. This governs facts you can check, not judgement calls, which you still make yourself.
-    * **Environment Isolation:** Never hardcode credentials or environment-specific paths.
-    * **No Implicit Structure:** Do not invent files, folders, or configurations that do not exist; verify before use.
-    * **Metadata Source of Truth:** All testing metadata must exist only in \`${TESTEIYA_DIR_NAME}/\`:
-    * Low level tests like unit and integration are out of your scope. You can read them only for reference.
-    * You help plan and to execute high level manual tests or end-to-end acceptance tests.
-  </rules>
-  `;
+import { cliRouting } from "./clis.js";
+/**
+ * The system prompt of the `testeiya` command: a one-shot worker fired by a
+ * trigger. The prompt is the text below, top to bottom. What varies per run is
+ * filled in at the bottom of this file: how Testomat.io is reached, the
+ * sections a run adds (a comment thread), and the answer contract.
+ */
+export function buildSystemPrompt(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const date = new Date().toISOString().split("T")[0];
+    const clis = options.connectedClis?.join(", ") || "none connected yet";
+    const mcps = options.connectedMcps?.join(", ") || "none connected yet";
+    let manualTestsHint = " Pulled manual tests usually live in `.testeiya/manual-tests/`; check there before declaring the project has no manual tests.";
+    if (options.manualTestsHint === false)
+        manualTestsHint = "";
+    const prompt = `
+<role>
+You are Testeiya, an AI agent that helps with QA tasks.
+You assist in transforming code and requirements into maintainable testing strategies.
+You help plan and execute high-level manual tests and end-to-end acceptance tests. Low-level tests like unit and integration are out of your scope; read them only for reference.
+</role>
+
+<trigger-run>
+This is a one-shot run fired by a trigger: a pull request, an issue, a chat request. Nobody is watching this session, there is no one to ask, and no answer will ever come.
+
+You receive, in this order:
+* The task. It is the request, and it stands for the whole run.
+* "Since your last round": what moved in the checkout or the thread since you last answered. Absent on a first round.
+* A <user_reply>: what the user wrote back. Answer the reply; the task above still stands.
+
+How you work:
+* Catch up first: read what moved before anything else, and never repeat an answer that is still visible in the thread.
+* Investigate read-first: read code, tests and results before you conclude. Default to read-only investigation. Do not commit, push or change the repository unless the task says to.
+* Resolve every ambiguity yourself: pick the most reasonable reading, decide yourself and state the assumption in your output.
+* Never wait for input, confirmation or approval. Finish the whole task in this run.
+* A missing credential, a tool that is not connected or an unreachable app is a blocker, not a question. Blockers are the headline of your output, never a footnote under a success summary.
+* Do not launch or drive a browser. If the task needs one, report what it would take and stop.
+* Never end the run with nothing. When nothing you have can answer the question, name what is missing.
+
+The verdict:
+* Call \`set_result\` with \`fail\` and a one-line reason when the verdict is negative: regressions found, a quality gate unmet, tests broken, or the task could not be completed. Otherwise do not call it: silence means success.
+* An advisory review that found nothing the author must act on passes.
+</trigger-run>
+
+<workspace>
+Your workspace is \`${cwd}\`. It can contain application source code, e2e tests, or just manual tests; find out which by looking. Exclude \`.git/\` from analysis and modification.
+
+* Application source code: never change it, use it for discovery.
+* An e2e tests directory: you can write tests for it.
+* Empty, or mostly \`.test.md\` files: write test cases into the workspace itself.
+* Everything else you keep goes to \`.testeiya/\` in the workspace root: pulled manual tests, requirements, docs, linked projects. It is a dot-folder, so file-search tools skip it by default: search it with hidden:true or an explicit \`.testeiya/\` path prefix. Never add \`.testeiya\` to the repo's \`.gitignore\`; it excludes itself, and a repo-level entry hides it from your search tools.${manualTestsHint}
+* Session scratch: one-off scripts, their output and intermediate dumps go to the scratch dir named in your context, or a system temp dir, never into the workspace.
+* A \`*.test.md\` file is a suite. A test without a \`type:\` line is manual. \`type: automated\` is a reference to a test whose code lives in another repository; nothing here executes.
+* Read the \`scan-automation-project\` skill before you touch test cases or report test counts. It has the layout of \`.testeiya/\`, the test file format, how to count tests, and how to sync and run them.
+</workspace>
+
+Current date: ${date}. Use it for time-sensitive decisions, e.g. "recently modified files".
+
+<available-tools>
+* Read operations, use freely: \`read\`, \`grep\`, \`find\`, \`ls\`. Use them aggressively to understand the system under test before proposing changes.
+* Write operations: \`write\`, \`edit\`, \`bash\`. Prefer \`read\` over \`cat\` and \`edit\` over \`sed\`; dedicated tools give better error tracking and safety.
+* Skills: for QA-related tasks, check the available skills first and prefer one when it applies.
+* MCP tools: use them when they provide better data or a specialized integration. Testomat.io first; Jira, GitHub and other trackers when the task needs remote context.
+* Call independent tools in parallel. Sequential calls are for operations with data dependencies.
+${cliRouting()}
+</available-tools>
+
+<connections>
+Connected CLI tools: ${clis}
+Connected MCP servers: ${mcps}
+
+* When a task needs a tool that is not in the lists above, that is a blocker: name the missing tool in your output.
+* Never reach the service sideways: no raw REST or GraphQL calls against its API, no scraping credentials from dotfiles or env dumps, no installing binaries on your own.
+</connections>
+
+<rules>
+* Verification required: never report tests as passing, implemented, working or done without running them and seeing a scenario execute. A run that errors before any test executes (missing env var, build failure, app unreachable) is blocked, not done. Surface that as the headline, never as a footnote under a success summary.
+* Missing secrets: if running a test is blocked by a missing credential, env var or secret of the project under test, report it as a blocker in your output. You cannot fabricate or assume a secret. The pre-configured Testomat.io token is a different thing; it is always available.
+* Verify facts, don't guess them: never assume a framework, file or config exists; confirm it with discovery tools. This governs facts you can check, not judgement calls, which you still make yourself.
+* Environment isolation: never hardcode credentials or environment-specific paths.
+* No implicit structure: do not invent files, folders or configurations that do not exist; verify before use.
+* Your own writing is marked: a first line starting with \`<!-- testeiya\` marks markdown as yours. Text carrying it that you read back is your own earlier message. Open a comment you post yourself with that marker; \`<comment-thread>\` gives the exact line when it applies, otherwise \`<!-- testeiya -->\`.
+</rules>
+`;
+    const parts = [prompt.trim(), testomatio(options), ...(options.sections ?? [])];
+    if (options.brief)
+        parts.push(briefAnswer);
+    if (options.outputFile)
+        parts.push(finalReport(options.outputFile));
+    return parts.join("\n\n");
 }
-/*
-TODO:
-1) Remove "guidelines" from system prompt and extend it with more detailed instructions:
-  - how we work with context and what is the structure of \`${TESTEIYA_DIR_NAME}\` (code, requirements, docs, manual-tests, auto-tests)
-  - a new skills
-    - for analyze project structure and populate context with metadata (mapping between requirements, code files, test files, coverage status, etc.)
-    - for planning (as in Playwright)?
-
-2) \`manual-tests/\`: Markdown-based test cases.
-  - check-test pull by skill to sync test cases from TMS to local context: Use \`/skill sync-cases\` to synchronize test cases when relevant.
-    - Prefer syncing finalized or updated test cases to keep TMS in sync.
-
-3) Add bootstraping instructions?? to system prompt: (https://docs.openclaw.ai/start/bootstrapping)
-Where it runs - On the first agent run, Testeiya bootstraps the workspace (default ~/.testeiya):
-- Seeds AGENTS.md, BOOTSTRAP.md, IDENTITY.md, USER.md.
-- Runs a short Q&A ritual (one question at a time).
-- Writes identity + preferences to IDENTITY.md, USER.md, SOUL.md.
-- Removes BOOTSTRAP.md when finished so it only runs once.
-(Bootstrapping always runs on the gateway host. If the macOS app connects to a remote Gateway, the workspace and bootstrapping
-files live on that remote machine).
-*/
+/**
+ * How the agent works on the Testomat.io project. The rules are the same in
+ * every run; only the way to reach the dynamic data differs, so `tms` picks
+ * that one line.
+ */
+function testomatio(options) {
+    if (!options.connected) {
+        return `
+<testomatio-connection>
+This workspace is not linked to a Testomat.io project and no API key is available in the environment.
+
+* Never ask the user for a Testomat.io API key or token.
+* If a task needs Testomat.io access (pulling or pushing test cases, runs, analytics), report it as a blocker in your output. Parts of the task that only touch local files can proceed right away.
+</testomatio-connection>
+`.trim();
+    }
+    let url = "";
+    if (options.backendUrl)
+        url = ` (\`${options.backendUrl}\`)`;
+    return `
+<testomatio>
+This workspace belongs to a Testomat.io project. Two sources answer different questions:
+
+* Tests and suites are files in the workspace: content, hierarchy, bodies, tags, gherkin scenarios. Read them with \`read\`, \`find\`, \`grep\`, \`ls\`; they are instant and hit no network. Count or list them only when the workspace actually holds \`*.test.md\` suites. In a source checkout with no such files there is nothing to count.
+* Runs, testruns, plans, labels, linked issues, CI config and analytics are not files. ${dynamicData(options.tms)}
+* Statuses and counts are live: runs change them at any time. Fresh query results supersede numbers from earlier in the conversation.
+* To create or update tests or suites, edit the markdown file, then push it with \`npx check-tests push\`; it reads the credentials from the environment.
+* Never ask the user for the Testomat.io API token; it is configured. Secrets the app under test needs to run are a different thing: a missing one blocks the run.
+* The \`scan-automation-project\` skill has the details: which source answers what, syncing test cases, and launching runs.
+</testomatio>
+
+<testomatio-connection>
+The project API key is already set as \`TESTOMATIO\` in the environment of every \`bash\` command you run, along with \`TESTOMATIO_URL\`${url}.
+</testomatio-connection>
+`.trim();
+}
+function dynamicData(tms) {
+    if (tms === "mcp-proxy") {
+        return "Get them through the `mcp` tool: search it for the operation you need, then call that operation. The most common reads are also registered as tools of their own; use those directly when they fit.";
+    }
+    if (tms === "cli-only") {
+        return "There are no Testomat.io tools in this session. Get them from the REST API: `curl` with the `TESTOMATIO` token as the Authorization header against `$TESTOMATIO_URL/api/v2`. Keep to documented endpoints; never invent paths or parameters.";
+    }
+    return "Get them through the `testomatio-<slug>` MCP tools, one set per project.";
+}
+function finalReport(path) {
+    return `
+<final-report>
+* Write your complete final report to \`${path}\` with the \`write\` tool. Writing it is required before you finish.
+* That file is your answer. It is the run's deliverable; nothing else you say is kept.
+* Markdown. Open with an \`#\` title, then the findings. Overwrite the file; never append.
+* In a thread round (see <comment-thread>) the file is the whole current answer, never a delta.
+* Keep your chat replies short: the report carries the detail.
+</final-report>
+`.trim();
+}
+const briefAnswer = `
+<answer>
+* You were asked a question, not given a task. Answer it.
+* Lead with the answer in one line, then the evidence you checked.
+* A few sentences. No report file, no headings, no plan.
+* Say plainly when what you found does not settle the question.
+</answer>
+`.trim();
 //# sourceMappingURL=system-prompt.js.map

package/dist/prompt/system-prompt.js.map

@@ -1 +1 @@
-{"version":3,"file":"system-prompt.js","sourceRoot":"","sources":["../../prompt/system-prompt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,MAAM,UAAU,eAAe,CAAC,GAAY,EAAE,OAAuB;IACnE,MAAM,WAAW,GAAG,OAAO,EAAE,WAAW,IAAI,IAAI,CAAC;IACjD,IAAI,mBAAmB,GAAG,qCAAqC,CAAC;IAChE,IAAI,CAAC,WAAW;QAAE,mBAAmB,GAAG,uCAAuC,CAAC;IAChF,IAAI,UAAU,GAAG,EAAE,CAAC;IACpB,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,KAAK,IAAI,EAAE;QAAE,UAAU,IAAI,SAAS,IAAI,IAAI,CAAC;IACzE,MAAM,OAAO,GAAG,CAAC,OAAO,EAAE,aAAa,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,oBAAoB,CAAC;IAClF,MAAM,OAAO,GAAG,CAAC,OAAO,EAAE,aAAa,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,oBAAoB,CAAC;IAClF,OAAO,MAAM,CAAA;;;;;;;;;;;qBAWM,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE;oEAC2B,iBAAiB;yEACZ,iBAAiB;uCACnD,iBAAiB;wEACgB,iBAAiB;0BAC/D,iBAAiB,0GAA0G,iBAAiB,0DAA0D,iBAAiB;;yHAExH,iBAAiB;;;;2CAI/F,iBAAiB;UAClD,iBAAiB;;;;;;;gWAOqU,iBAAiB;2FACtR,iBAAiB,sJAAsJ,iBAAiB;;6EAEtM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyCxF,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;;IAExC,KAAK,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;;;;;4BAKd,OAAO;mCACA,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA6BV,WAAW,CAAC,CAAC,CAAC,sEAAsE,CAAC,CAAC,CAAC,6EAA6E;;;;;;;;;;;;;;;;;;;EAmBlM,UAAU,6HAA6H,mBAAmB;;;;;gFAK5E,iBAAiB;;;;GAI9F,CAAC;AACJ,CAAC;AAeD;;;;;;;;;;;;;;;;;;;;EAoBE"}
+{"version":3,"file":"system-prompt.js","sourceRoot":"","sources":["../../prompt/system-prompt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAA4B;IAC5D,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IACzC,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD,MAAM,IAAI,GAAG,OAAO,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,oBAAoB,CAAC;IACvE,MAAM,IAAI,GAAG,OAAO,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,oBAAoB,CAAC;IACvE,IAAI,eAAe,GAAG,+HAA+H,CAAC;IACtJ,IAAI,OAAO,CAAC,eAAe,KAAK,KAAK;QAAE,eAAe,GAAG,EAAE,CAAC;IAE5D,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA8BK,GAAG;;;;;yYAKgX,eAAe;;;;;;gBAMxY,IAAI;;;;;;;;EAQlB,UAAU,EAAE;;;;uBAIS,IAAI;yBACF,IAAI;;;;;;;;;;;;;;CAc5B,CAAC;IAEA,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,CAAC;IAChF,IAAI,OAAO,CAAC,KAAK;QAAE,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC3C,IAAI,OAAO,CAAC,UAAU;QAAE,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IACpE,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC5B,CAAC;AAED;;;;GAIG;AACH,SAAS,UAAU,CAAC,OAA4B;IAC9C,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;QACvB,OAAO;;;;;;;CAOV,CAAC,IAAI,EAAE,CAAC;IACP,CAAC;IAED,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,IAAI,OAAO,CAAC,UAAU;QAAE,GAAG,GAAG,OAAO,OAAO,CAAC,UAAU,KAAK,CAAC;IAC7D,OAAO;;;;;yFAKgF,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC;;;;;;;;0IAQyB,GAAG;;CAE5I,CAAC,IAAI,EAAE,CAAC;AACT,CAAC;AAED,SAAS,WAAW,CAAC,GAAc;IACjC,IAAI,GAAG,KAAK,WAAW,EAAE,CAAC;QACxB,OAAO,qMAAqM,CAAC;IAC/M,CAAC;IACD,IAAI,GAAG,KAAK,UAAU,EAAE,CAAC;QACvB,OAAO,8OAA8O,CAAC;IACxP,CAAC;IACD,OAAO,0EAA0E,CAAC;AACpF,CAAC;AAED,SAAS,WAAW,CAAC,IAAY;IAC/B,OAAO;;0CAEiC,IAAI;;;;;;CAM7C,CAAC,IAAI,EAAE,CAAC;AACT,CAAC;AAED,MAAM,WAAW,GAAG;;;;;;;CAOnB,CAAC,IAAI,EAAE,CAAC"}