@nexrall/code-core 1.4.22 → 1.4.24

package/dist/agent/agentTypes.d.ts

@@ -8,10 +8,43 @@ export interface AgentType {
     /** System instructions (the markdown body below the frontmatter). */
     prompt: string;
     source: 'project' | 'global' | 'builtin' | 'plugin';
+    /**
+     * When true, this agent's write tools may only target TEST files.
+     *
+     * Needed because a tool allowlist is all-or-nothing per tool: granting
+     * `edit_file` grants it for every path. The `test-writer` agent must be able to
+     * write tests while being unable to "fix" production source to make a test
+     * pass — the single most common way a test-writing agent destroys signal — and
+     * a prompt instruction alone cannot guarantee that. Enforced in loop.ts's
+     * permission gate, where it is a real refusal rather than a request.
+     */
+    testFilesOnly?: boolean;
 }
-/** Discover all custom agent types (project overrides global overrides builtin). */
+/**
+ * Discover all agent types. Precedence: project > global > plugin > builtin.
+ *
+ * Results are returned in a STABLE order (builtins in declared order, then
+ * user-supplied ones alphabetically) rather than in discovery order. The
+ * system-prompt catalogue is built from this, and a set that reshuffles between
+ * runs would silently bust the prompt cache on the block it lives in — filesystem
+ * readdir order is not guaranteed to be stable across machines or platforms.
+ */
 export declare function loadAgentTypes(workDir: string): AgentType[];
-/** A compact catalogue injected into the system prompt so the model can pick a type. */
+/**
+ * One line per agent for the system prompt's <available_subagents> block.
+ *
+ * Reports each agent's CAPABILITY CLASS rather than enumerating its allowlist.
+ * The full lists (~15 tool names each) went into every single request while
+ * telling the model nothing it needs in order to choose: what matters when
+ * delegating is "can this one edit files?" and "what is it for?", not whether
+ * `get_hover` happens to be included. With six builtins the verbatim lists cost
+ * ~670 tokens per request, most of it near-identical boilerplate that also
+ * weakens the signal it was meant to carry.
+ *
+ * The per-agent description already states its own restrictions in prose, and the
+ * allowlist is enforced at the permission gate regardless of what is advertised
+ * here — so this is purely a summary, never the mechanism.
+ */
 export declare function summariseAgents(types: AgentType[]): string;
 export declare function findAgentType(types: AgentType[], name: string | undefined): AgentType | undefined;
 //# sourceMappingURL=agentTypes.d.ts.map

package/dist/agent/agentTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agentTypes.d.ts","sourceRoot":"","sources":["../../src/agent/agentTypes.ts"],"names":[],"mappings":"AAuBA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;IAClC,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;CACrD;AAoFD,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAS3D;AAED,wFAAwF;AACxF,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAQ1D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAIjG"}
+{"version":3,"file":"agentTypes.d.ts","sourceRoot":"","sources":["../../src/agent/agentTypes.ts"],"names":[],"mappings":"AAuBA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;IAClC,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IACpD;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AA4RD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAmB3D;AACD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAY1D;AAQD,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAIjG"}

package/dist/agent/agentTypes.js

@@ -43,11 +43,37 @@ const index_1 = require("../plugins/index");
 // ── Built-in agent types ──────────────────────────────────────────────────────
 // Shipped defaults; lowest precedence (project > global > builtin), so a user
 // can override any of them with a same-name .nexrall/agents/<name>.md file.
+// Shared read-only tool set.
+//
+// An allowlist only ever GRANTS — a name that doesn't exist on the current client
+// is simply never offered to the model, so listing the VS Code language-server
+// tools alongside the CLI ones is safe and gives each agent the best available
+// capability on whichever client it runs.
+//
+// This exists because it was previously inlined per agent, and the one agent that
+// had it (`reviewer`) listed five VS Code-only tools, leaving it with just five
+// usable tools when run from the CLI — a silent capability gap that is very easy
+// to reintroduce by copy-pasting a list.
+const READ_ONLY_TOOLS = [
+    // Universal
+    'read_file', 'search_files', 'glob', 'list_directory', 'bash', 'bash_output',
+    'notebook_read', 'todo_write', 'todo_read',
+    // VS Code language server (ignored on the CLI)
+    'get_symbols', 'get_workspace_symbols', 'find_references', 'go_to_definition',
+    'get_hover', 'get_diagnostics',
+];
+/** Read-only + the network, for agents that must consult external sources. */
+const RESEARCH_TOOLS = [...READ_ONLY_TOOLS, 'web_search', 'fetch_url'];
+/** Read-only + the write tools, for agents that produce code. */
+const WRITE_TOOLS = [
+    ...READ_ONLY_TOOLS,
+    'write_file', 'edit_file', 'multi_edit', 'create_directory', 'move_file', 'copy_file',
+];
 const BUILTIN_AGENTS = [
     {
         name: 'reviewer',
         description: 'Read-only code reviewer — finds correctness bugs, edge cases, and security issues in a diff or file set. Cannot modify files.',
-        tools: ['read_file', 'search_files', 'glob', 'list_directory', 'bash', 'get_symbols', 'get_workspace_symbols', 'find_references', 'go_to_definition', 'get_diagnostics'],
+        tools: READ_ONLY_TOOLS,
         source: 'builtin',
         prompt: [
             'You are a meticulous senior code reviewer. You NEVER modify files — you only read, search, and report.',
@@ -64,6 +90,162 @@ const BUILTIN_AGENTS = [
             'then a final verdict (APPROVE or REQUEST CHANGES) with a one-paragraph rationale.',
         ].join('\n'),
     },
+    // Promoted from the security-audit plugin to a builtin.
+    //
+    // Leaving it plugin-only was indefensible next to `reviewer` being builtin:
+    // reviewer's own prompt already tells it to look for security issues, so
+    // security IS treated as default work — yet the specialist agent for it was
+    // invisible unless the user happened to know the plugin existed. For an agent
+    // that WRITES code, "you only get a security review if you knew to install
+    // something" is the wrong default.
+    {
+        name: 'security-auditor',
+        description: 'Read-only security auditor — hunts injection, authz, secrets, and validation flaws in a path or diff. Cannot modify files.',
+        tools: READ_ONLY_TOOLS,
+        model: 'pro',
+        source: 'builtin',
+        prompt: [
+            'You are a security auditor. You find real, exploitable flaws — not style issues.',
+            '',
+            'Method:',
+            '1. Map the attack surface FIRST: entry points (HTTP routes, message handlers, CLI args, file/network',
+            '   input, deserialization), then trace user-controlled data inward to where it is used.',
+            '2. For each finding: file:line, the flaw class, a one-line exploit scenario, and the concrete fix.',
+            '3. Grade severity honestly: Critical = remote compromise or data breach; High = auth bypass/IDOR;',
+            '   Medium = needs unusual preconditions; Low = hardening.',
+            '',
+            'Classes worth the most attention, in order: injection (SQL/command/template/prototype), broken',
+            'authz (missing ownership checks, IDOR, trusting client-supplied ids), secrets committed to source,',
+            'path traversal, SSRF, unsafe deserialization, missing rate limits on expensive or auth endpoints,',
+            'and crypto misuse (hand-rolled comparison, predictable randomness).',
+            '',
+            'Hard rules:',
+            '- READ-ONLY: never modify, create or delete files. bash only for read-only inspection.',
+            '- NEVER print a discovered secret\'s value. Report its location and advise rotation.',
+            '- Distinguish EXPLOITABLE from theoretical, and say which one each finding is.',
+            '- "No issues found in scope X" is a valid, useful result. Do not pad the report to look thorough.',
+        ].join('\n'),
+    },
+    // The gap Claude Code fills with its built-in `Explore`: read-heavy codebase
+    // search that would otherwise flood the parent's context. Defaults to the
+    // cheapest model on purpose — "find every caller of X" has no need of a
+    // frontier model, and this is the agent most likely to be spawned in bulk.
+    {
+        name: 'explorer',
+        description: 'Fast read-only codebase explorer — locates files, symbols, and call sites and reports concise findings. Use to keep bulk searching out of the main context. Cannot modify files.',
+        tools: READ_ONLY_TOOLS,
+        model: 'turbo',
+        source: 'builtin',
+        prompt: [
+            'You map code. You NEVER modify anything.',
+            '',
+            'Method:',
+            '1. Prefer structural search over text search where available (get_workspace_symbols, find_references,',
+            '   go_to_definition); fall back to search_files/glob otherwise.',
+            '2. Read only the sections you need — use read_file with offset/limit on large files instead of',
+            '   pulling in thousands of lines.',
+            '3. Follow the real call graph rather than guessing from names.',
+            '',
+            'Your ONLY output is a compact report: the file:line locations that matter, how they relate, and the',
+            'direct answer to the question you were given. This exists to keep bulk search OUT of the parent\'s',
+            'context, so do not paste large file contents back — cite locations and summarise. Say plainly when',
+            'something does not exist; a confident wrong answer is far worse than "not found".',
+        ].join('\n'),
+    },
+    // Matches Claude Code's built-in `Plan`: research a change and return a
+    // strategy, deliberately WITHOUT write access so "make a plan" can never
+    // quietly become "start editing".
+    {
+        name: 'planner',
+        description: 'Read-only planning agent — researches a change and returns a concrete step-by-step implementation plan with risks and affected files. Cannot modify files.',
+        tools: RESEARCH_TOOLS,
+        model: 'pro',
+        source: 'builtin',
+        prompt: [
+            'You produce implementation plans. You NEVER modify files — planning and doing are separate steps,',
+            'and this agent exists so "plan it" cannot silently turn into "change it".',
+            '',
+            'Method:',
+            '1. Read the actual code before proposing anything. No plan may rest on an assumed API shape.',
+            '2. Find every affected call site (find_references / search_files) and list them.',
+            '3. Order the steps so the tree stays working after each one — types, then implementation, then',
+            '   tests, then exports/registration.',
+            '',
+            'Output:',
+            '- Goal, in one sentence.',
+            '- Numbered steps, each with the exact files touched and what changes in them.',
+            '- Risks + the specific thing that could break, and how it would be detected.',
+            '- How to verify (the exact test/build command for THIS project, taken from package.json/Makefile).',
+            '- Anything genuinely ambiguous, stated as an open question rather than a silent assumption.',
+        ].join('\n'),
+    },
+    // Promoted from the test-gen plugin. Needs write access — it produces test
+    // files — but is deliberately forbidden from touching source, because "make the
+    // tests pass" is the single most common way an agent destroys signal.
+    {
+        name: 'test-writer',
+        description: 'Writes tests that follow the project\'s existing conventions. May create/edit TEST files only — never production source.',
+        tools: WRITE_TOOLS,
+        // Enforced, not merely requested: the permission gate refuses a write whose
+        // path is not a test file. Without this the allowlist would grant edit_file
+        // for every path and the rule below would be a suggestion the model is free
+        // to rationalise its way past.
+        testFilesOnly: true,
+        source: 'builtin',
+        prompt: [
+            'You write tests. You may create and edit TEST files only.',
+            '',
+            'Hard rules — these are the ways test-writing agents destroy value, so they are non-negotiable:',
+            '- NEVER modify production source to make a test pass. If the code looks wrong, REPORT it and stop.',
+            '- NEVER weaken, delete or skip an existing assertion or test.',
+            '- A test that cannot fail is worse than no test. Every test must be able to fail for one clear reason.',
+            '',
+            'Method:',
+            '1. Read the existing tests FIRST and copy their conventions exactly — runner, file naming, layout,',
+            '   assertion style, fixture/helper patterns. Never introduce a new framework.',
+            '2. Test observable behaviour and the contract, not private internals.',
+            '3. Cover the boring-but-real cases: empty input, null/undefined, unicode and non-BMP characters,',
+            '   boundaries, error paths, concurrency where it applies.',
+            '4. No sleeps or wall-clock dependence — those produce the flaky tests that get deleted later.',
+            '5. RUN the tests you wrote and report the real output. Never claim a test passes without running it.',
+        ].join('\n'),
+    },
+    // The DevOps gap — answered with a READ-ONLY advisor, not an operator.
+    //
+    // A "DevOps agent" with write/apply access is a genuinely different risk class
+    // from the others here: its mistakes are `kubectl delete`, a bad `terraform
+    // apply`, a broken deploy pipeline — often not revertible and affecting
+    // production rather than a working tree. So this one diagnoses and proposes a
+    // diff; a human applies it. That asymmetry is the whole design.
+    {
+        name: 'devops-advisor',
+        description: 'Read-only CI/CD, container, and infrastructure advisor — diagnoses pipelines, Dockerfiles, and k8s manifests and proposes concrete fixes as a diff. Never applies changes.',
+        tools: RESEARCH_TOOLS,
+        model: 'pro',
+        source: 'builtin',
+        prompt: [
+            'You are an infrastructure and delivery advisor. You DIAGNOSE and PROPOSE. You never apply changes.',
+            '',
+            'Hard rules:',
+            '- READ-ONLY, and stricter than the other read-only agents: bash is for INSPECTION only',
+            '  (git log/diff, cat, grep, `kubectl get/describe`, `docker images`, `terraform plan`).',
+            '  NEVER run anything that mutates infrastructure — no apply/delete/scale/rollout/restart/push,',
+            '  no `terraform apply`, no `helm upgrade`. If a fix needs such a command, WRITE IT OUT for a human.',
+            '- Never print secret values from env files, k8s Secrets or CI variables. Reference them by name.',
+            '',
+            'Method:',
+            '1. Read what actually exists — workflow files, Dockerfiles, manifests, kustomize overlays, the',
+            '   deploy scripts — before drawing any conclusion. Never reason from what a stack "usually" looks like.',
+            '2. Follow the real path a change takes to production, and name the step that is broken or missing.',
+            '3. Check the failure modes that bite hardest: CI path filters that skip files a workload actually',
+            '   needs, image tags that do not match what is deployed, missing health probes, absent resource',
+            '   limits, secrets baked into images, ports/timeouts inconsistent between proxy and app, and',
+            '   migrations that must run before the new image is live.',
+            '',
+            'Output: the diagnosis, the evidence (file:line or command output), the proposed change as a diff or',
+            'exact file content, and the command a human should run to apply and verify it.',
+        ].join('\n'),
+    },
 ];
 function parseFrontmatter(raw) {
     const m = /^\s*---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
@@ -81,6 +263,10 @@ function parseModel(v) {
     const s = (v ?? '').toLowerCase();
     return s === 'turbo' || s === 'pro' || s === 'ultra' ? s : undefined;
 }
+/** Parse a frontmatter boolean, accepting the usual truthy spellings. */
+function parseBool(v) {
+    return /^(true|yes|1|on)$/i.test((v ?? '').trim());
+}
 function parseToolList(v) {
     if (!v)
         return undefined;
@@ -116,6 +302,11 @@ function loadDir(dir, source, into) {
                 model: parseModel(meta.model),
                 prompt: body,
                 source,
+                // Exposed to user/plugin definitions too — `test_files_only: true` (or
+                // `testFilesOnly`) lets anyone build a test-writing agent that genuinely
+                // cannot touch production source, rather than only the builtin getting
+                // that guarantee.
+                ...(parseBool(meta.test_files_only ?? meta.testfilesonly) ? { testFilesOnly: true } : {}),
             });
         }
         catch {
@@ -123,7 +314,15 @@ function loadDir(dir, source, into) {
         }
     }
 }
-/** Discover all custom agent types (project overrides global overrides builtin). */
+/**
+ * Discover all agent types. Precedence: project > global > plugin > builtin.
+ *
+ * Results are returned in a STABLE order (builtins in declared order, then
+ * user-supplied ones alphabetically) rather than in discovery order. The
+ * system-prompt catalogue is built from this, and a set that reshuffles between
+ * runs would silently bust the prompt cache on the block it lives in — filesystem
+ * readdir order is not guaranteed to be stable across machines or platforms.
+ */
 function loadAgentTypes(workDir) {
     const out = new Map();
     loadDir(path.join(workDir, '.nexrall', 'agents'), 'project', out);
@@ -134,19 +333,55 @@ function loadAgentTypes(workDir) {
         if (!out.has(agent.name))
             out.set(agent.name, agent);
     }
-    return [...out.values()];
+    // Builtins first in their declared order (the common, cache-friendly case), then
+    // everything user-supplied alphabetically.
+    const builtinOrder = new Map(BUILTIN_AGENTS.map((a, i) => [a.name, i]));
+    return [...out.values()].sort((a, b) => {
+        const ai = builtinOrder.get(a.name);
+        const bi = builtinOrder.get(b.name);
+        if (ai !== undefined && bi !== undefined)
+            return ai - bi;
+        if (ai !== undefined)
+            return -1;
+        if (bi !== undefined)
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
 }
-/** A compact catalogue injected into the system prompt so the model can pick a type. */
+/**
+ * One line per agent for the system prompt's <available_subagents> block.
+ *
+ * Reports each agent's CAPABILITY CLASS rather than enumerating its allowlist.
+ * The full lists (~15 tool names each) went into every single request while
+ * telling the model nothing it needs in order to choose: what matters when
+ * delegating is "can this one edit files?" and "what is it for?", not whether
+ * `get_hover` happens to be included. With six builtins the verbatim lists cost
+ * ~670 tokens per request, most of it near-identical boilerplate that also
+ * weakens the signal it was meant to carry.
+ *
+ * The per-agent description already states its own restrictions in prose, and the
+ * allowlist is enforced at the permission gate regardless of what is advertised
+ * here — so this is purely a summary, never the mechanism.
+ */
 function summariseAgents(types) {
     if (!types.length)
         return '';
     return types
         .map((t) => {
-        const tools = t.tools ? ` (tools: ${t.tools.join(', ')})` : '';
-        return `- ${t.name}: ${t.description}${tools}`;
+        const canWrite = !t.tools || t.tools.some((x) => WRITE_TOOL_HINTS.has(x));
+        const access = t.testFilesOnly
+            ? 'writes TEST files only'
+            : canWrite ? 'can modify files' : 'read-only';
+        const model = t.model ? `, ${t.model} model` : '';
+        return `- ${t.name} (${access}${model}): ${t.description}`;
     })
         .join('\n');
 }
+/** Tool names that imply write access, for the summary line above. */
+const WRITE_TOOL_HINTS = new Set([
+    'write_file', 'edit_file', 'multi_edit', 'notebook_edit',
+    'delete_file', 'move_file', 'copy_file',
+]);
 function findAgentType(types, name) {
     if (!name)
         return undefined;

package/dist/agent/loop.d.ts

@@ -1,5 +1,41 @@
 import type { Message, AgentLoopOptions, EnvContext } from '../types';
 export declare function resolveMaxIterations(optionValue: number | undefined, settingsRaw: Record<string, unknown>): number;
+/**
+ * Minimal concurrency gate. Hand-rolled rather than pulling in `p-limit` because
+ * the CLI ships as a single esbuild bundle with no node_modules, and this is a
+ * dozen lines.
+ */
+export declare function createLimiter(max: number): <T>(fn: () => Promise<T>) => Promise<T>;
+/**
+ * Reduce a sub-agent's message history to the text its parent should receive.
+ *
+ * Pure + exported so the salvage rules can be tested without running a real
+ * sub-agent (which needs a live model stream and, for the timeout path, ten
+ * minutes of wall clock).
+ *
+ * `preferLast` — the normal completion path — returns the final assistant
+ * message, which is the sub-agent's actual answer.
+ *
+ * `preferLast: false` is the SALVAGE path, used when the sub-agent was cut off.
+ * A stopped sub-agent usually has no closing summary at all (it was killed
+ * mid-tool-round), so the last assistant message is frequently empty or a
+ * fragment. Concatenating what it did produce is far more useful to the parent
+ * model than nothing: it can build on the work instead of redoing it.
+ */
+export declare function extractSubTaskText(messages: Message[], preferLast?: boolean): string;
+/** Apply the parent-context cap to a sub-task's text, keeping head + tail. */
+export declare function capSubTaskText(text: string, max?: number): string;
+/**
+ * Summarise what a cut-short sub-agent actually accomplished, so the parent model
+ * can continue from it rather than starting over.
+ *
+ * This is the whole point of the salvage path. Previously a timed-out sub-agent
+ * returned ONLY an error string: ten minutes of work, dozens of tool calls and
+ * any files it wrote were invisible to the parent, which typically responded by
+ * re-running the same work from scratch — while the tokens for the discarded run
+ * had already been billed in full.
+ */
+export declare function summariseSubTaskProgress(messages: Message[]): string;
 /** The context window (tokens) for a model alias — the same lookup runAgentLoop uses internally. */
 export declare function contextWindowFor(model?: 'turbo' | 'pro' | 'ultra'): number;
 /** Auto-prune / auto-compact thresholds as fractions of the context window — for UI display (e.g. `/context`). */
@@ -11,6 +47,26 @@ export declare function compactionThresholds(): {
 export declare function estimateBodyBytes(messages: Message[]): number;
 /** Tools that mutate the filesystem — used by the verification nudge (GAP D). */
 export declare const WRITE_TOOL_NAMES: Set<string>;
+/**
+ * May an agent restricted to `testFilesOnly` perform this tool call?
+ *
+ * A tool allowlist is all-or-nothing per tool: granting `edit_file` grants it for
+ * every path in the repo. The `test-writer` agent needs write access to produce
+ * tests, but must NOT be able to "fix" production source so a failing test goes
+ * green — the single most common way a test-writing agent destroys the signal it
+ * was asked to create. Its prompt says so; this makes it a refusal rather than a
+ * request.
+ *
+ * Pure + exported so the rules are testable directly, without running a real
+ * sub-agent.
+ *
+ * KNOWN LIMIT, stated rather than hidden: this gates the file TOOLS, not `bash`.
+ * A determined model could still write source via `bash: echo ... > src/x.ts`.
+ * Closing that means parsing shell redirection, which is not reliably doable — so
+ * this is a strong guardrail against the realistic failure mode, not a sandbox.
+ * Real isolation is the sandbox config (tools/sandbox.ts), a separate mechanism.
+ */
+export declare function allowsTestOnlyWrite(tool: string, input: Record<string, unknown> | undefined): boolean;
 /** Heuristic: does a bash command look like it's running tests/build/lint/typecheck? (GAP D) */
 export declare const VERIFY_CMD_RE: RegExp;
 /**

package/dist/agent/loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAMP,gBAAgB,EAChB,UAAU,EACX,MAAM,UAAU,CAAC;AAyKlB,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,CAWR;AAsUD,oGAAoG;AACpG,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,CAE1E;AA8BD,kHAAkH;AAClH,wBAAgB,oBAAoB,IAAI;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAEzE;AAuBD,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAM7D;AAsBD,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,aAA+G,CAAC;AAC7I,gGAAgG;AAChG,eAAO,MAAM,aAAa,QAA2J,CAAC;AAEtL;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK5E;AAUD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAwBxD;AAoBD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,aAAa,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,qFAAqF;IACrF,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,YAAY,IAAI,cAAc,CAE7C;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,EAAE,EAAE,OAAO,EACX,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAoDN;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CA6B5D;AAmBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,eAAe,SAAI,GAAG,MAAM,CAgCpF;AAsKD,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAE/D;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,EAAE;IACJ,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC,GACA,OAAO,CAAC,OAAO,CAAC,CAqElB;AAID,wBAAsB,YAAY,CAChC,eAAe,EAAE,OAAO,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CAktBpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAqCtE"}
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"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"}