@xemahq/opencode-client 0.1.1

package/dist/lib/agents/types.d.ts

@@ -0,0 +1,24 @@
+export interface AgentConfig {
+    systemPrompt: string;
+    samplingProfile?: import('@xemahq/kernel-contracts/workflow').SamplingProfile;
+    directLlm?: boolean;
+    openCodeAgent?: string;
+    contextFiles?: Array<{
+        path: string;
+        reason: string;
+    }>;
+    mcpProfileKey?: string;
+    mcpServices?: string[];
+}
+export declare enum AgentCategory {
+    Pipeline = "pipeline",
+    GateReviewer = "gate-reviewer",
+    Utility = "utility",
+    PrePipeline = "pre-pipeline"
+}
+export interface AgentRegistration {
+    readonly key: string;
+    readonly category: AgentCategory;
+    readonly config: AgentConfig;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/agents/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/agents/types.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,WAAW;IAE1B,YAAY,EAAE,MAAM,CAAC;IAUrB,eAAe,CAAC,EAAE,OAAO,mCAAmC,EAAE,eAAe,CAAC;IAM9E,SAAS,CAAC,EAAE,OAAO,CAAC;IAKpB,aAAa,CAAC,EAAE,MAAM,CAAC;IAOvB,YAAY,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAMvD,aAAa,CAAC,EAAE,MAAM,CAAC;IAKvB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAeD,oBAAY,aAAa;IACvB,QAAQ,aAAa;IACrB,YAAY,kBAAkB;IAC9B,OAAO,YAAY;IACnB,WAAW,iBAAiB;CAC7B;AAOD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B"}

package/dist/lib/agents/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentCategory = void 0;
+var AgentCategory;
+(function (AgentCategory) {
+    AgentCategory["Pipeline"] = "pipeline";
+    AgentCategory["GateReviewer"] = "gate-reviewer";
+    AgentCategory["Utility"] = "utility";
+    AgentCategory["PrePipeline"] = "pre-pipeline";
+})(AgentCategory || (exports.AgentCategory = AgentCategory = {}));
+//# sourceMappingURL=types.js.map

package/dist/lib/agents/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lib/agents/types.ts"],"names":[],"mappings":";;;AAyEA,IAAY,aAKX;AALD,WAAY,aAAa;IACvB,sCAAqB,CAAA;IACrB,+CAA8B,CAAA;IAC9B,oCAAmB,CAAA;IACnB,6CAA4B,CAAA;AAC9B,CAAC,EALW,aAAa,6BAAb,aAAa,QAKxB"}

package/dist/lib/control-plane/agents-md-sections.d.ts

@@ -0,0 +1,11 @@
+type AgentCategory = 'builder' | 'coordinator' | 'reviewer' | 'utility' | 'pre-pipeline' | 'deployment';
+export type InstructionMutabilityTier = 'system_locked' | 'system_default';
+export interface InstructionSectionSeed {
+    sectionKey: string;
+    content: string;
+    categories: AgentCategory[];
+    mutabilityTier: InstructionMutabilityTier;
+}
+export declare const INSTRUCTION_SECTION_SEEDS: InstructionSectionSeed[];
+export {};
+//# sourceMappingURL=agents-md-sections.d.ts.map

package/dist/lib/control-plane/agents-md-sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents-md-sections.d.ts","sourceRoot":"","sources":["../../../src/lib/control-plane/agents-md-sections.ts"],"names":[],"mappings":"AA8BA,KAAK,aAAa,GACd,SAAS,GACT,aAAa,GACb,UAAU,GACV,SAAS,GACT,cAAc,GACd,YAAY,CAAC;AAkYjB,MAAM,MAAM,yBAAyB,GAAG,eAAe,GAAG,gBAAgB,CAAC;AAG3E,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,cAAc,EAAE,yBAAyB,CAAC;CAC3C;AAcD,eAAO,MAAM,yBAAyB,EAAE,sBAAsB,EA6C1D,CAAC"}

package/dist/lib/control-plane/agents-md-sections.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTRUCTION_SECTION_SEEDS = void 0;
+function buildWorkspaceMaterialModelSection() {
+    return '';
+}
+const EXECUTION_DISCIPLINE = `
+## Execution Discipline
+
+- **Read AGENTS.md first**: Before anything else, call \`read\` on \`/workspace/AGENTS.md\`. This is mandatory for every agent on every turn.
+- **Plan first**: Before your first tool call, identify deliverables, required context, and execution sequence. Then act decisively.
+- **Mandatory task tracking**: Use \`todowrite\` for every multi-step task, keep one item \`in_progress\`, and only finish when all todos are \`completed\`.
+- **Persist until done**: If you hit an obstacle, try alternatives before reporting inability. Retry failed tool calls with corrected params.
+- **No partial work**: Complete the phase fully or clearly report what remains and why.
+`.trim();
+const EVIDENCE_DISCIPLINE = `
+## Evidence Discipline
+
+Every action you take must produce traceable evidence:
+- **File changes**: Note every file created, modified, or deleted.
+- **Commands executed**: Record every shell command and its outcome (pass/fail).
+- **Decisions made**: Document WHY you chose approach A over approach B.
+- **Verification**: Run verification commands (build, test, lint) and report results.
+- **Risk signals**: Flag any concerns — large change sets, missing tests, security implications.
+
+The platform collects this evidence automatically from your tool calls.
+Focus on producing clean, verifiable work — the evidence pack is built post-execution.
+`.trim();
+const REPORT_VS_DELIVERABLES = `
+## Report vs Deliverables — Two Separate Deliverables
+
+1. **DELIVERABLES** — actual work products created via MCP tools, file writes, or git. WHERE they go depends on your output channel rules.
+2. **REPORT** — your text response. A structured account of what you did, NOT the deliverable content itself.
+
+**Rules:**
+- Report references deliverables by ID — it does NOT contain their content.
+- Never dump full document/code content into the report as a "backup".
+- If an MCP tool fails, retry with corrected params. If still failing, report the failure honestly — never fabricate deliverable references.
+- Gate reviewers WILL cross-check your claims against actual artifacts.
+`.trim();
+const MEMORY_PRECEDENCE = `
+## Memory Precedence Rule
+
+When recalled memories conflict with current-run decisions:
+- Current pipeline run's clarification decisions and requirements are AUTHORITATIVE.
+- Prior-run project memories are ADVISORY only — use them as context, not constraints.
+- Global (org-wide) memories are ADVISORY only unless they are explicit org-level constraints.
+- If a global memory contradicts a current-run decision, the current-run decision wins.
+`.trim();
+const WORKSPACE_MATERIAL_MODEL = buildWorkspaceMaterialModelSection();
+const CORRECTION_RECALL = `
+## Corrections & Constraints — Highest Priority
+
+Corrections from past runs are **pre-loaded into your context** (see "Prior Phase Context" / "Memories" sections above).
+All memory is already injected — start from the provided context.
+
+Handle corrections by confidence tier:
+- **autoApply** (≥0.8): Follow without question — these override your default approach.
+- **mention** (0.5–0.79): Include in reasoning, tell the user you're applying it.
+- **suggest** (<0.5): Consider but don't auto-apply.
+
+Corrections override gate feedback when they conflict. Never ignore autoApply corrections.
+`.trim();
+const GATE_FEEDBACK = `
+## Learning From Past Gate Feedback
+
+Gate feedback and platform best practices are **pre-loaded into your context** (see "Prior Phase Context" / "Memories" sections above).
+All feedback is already injected — start from the provided context.
+
+Apply the lessons:
+- Gate rejection memories are HIGH-PRIORITY constraints — they represent real failures.
+- Platform-scope memories are established best practices — deviate only with explicit justification.
+- If past feedback conflicts with current task requirements, the current task takes priority (note the deviation).
+
+If you discover actionable, reusable learnings during your work, include them in the manifest \`analyticalFindings\`. Memory creation happens automatically from gate feedback and outcomes.
+`.trim();
+const FILE_FIRST_OUTPUT = `
+## File-First Output — Write Files, Harvest Server-Side
+
+### The Rule: Your Deliverables Are JSON + Markdown Files on Disk
+
+You produce your phase output by writing plain files to \`/workspace/\`.
+The orchestrator harvests them after your turn completes, validates
+them against the published output contracts, and sends an in-session
+correction if anything is missing or malformed. No special emit tools —
+just \`write\`.
+
+### Page editing
+
+Your pre-scaffolded pages live at \`deliverables/pages/<slug>.md\`. Edit in
+place with \`md_edit\`, \`edit\`, \`patch\`, or \`write\`. Allowed slugs are
+in \`context.json.authority.mayWriteSlugs\`; the biome rejects
+unauthorized writes at \`tool.execute.before\` with a typed error.
+
+### Required output files
+
+| File | Contents |
+|------|----------|
+| \`deliverables/manifest.json\` | One entry per page: \`{ slug, title, contentFile }\`. System fields (schemaVersion, phaseKey, runId, timestamp, manifestHash) are injected at harvest — do not populate them. Written LAST, after all page files are on disk. |
+| \`deliverables/analysis.json\` | Structured decisions, assumptions, conflicts, analytical findings. Optional — omit if you have nothing to record. |
+| \`deliverables/page-expansion-proposal.json\` | When scope requires adding pages beyond the scaffold, propose them here (slug, title, rationale). Optional. |
+
+### Completion signal
+
+The orchestrator treats your turn as complete when the SSE stream
+reaches \`session.idle\`. It then reads the files above. If any are
+missing, malformed, or fail validation, you receive a correction
+message listing each issue — fix and your next turn re-runs harvest.
+
+Without a valid \`deliverables/manifest.json\`, your work is not saved.
+
+### What Goes WHERE
+
+| Content Type | Channel |
+|---|---|
+| Page bodies | \`deliverables/pages/<slug>.md\` (any mutation tool) |
+| Phase manifest | \`deliverables/manifest.json\` (\`write\`) |
+| Phase analysis | \`deliverables/analysis.json\` (\`write\`) |
+| Page-expansion proposal | \`deliverables/page-expansion-proposal.json\` (\`write\`) |
+| Backlog items | direct MCP (\`backlog_create_item\`) |
+| Artifact registration | direct MCP (\`artifact_create\`) |
+| Code / config files | \`write\` / \`edit\` / \`patch\` to repo paths |
+`.trim();
+const STANDARD_REPORT_FORMAT = `
+## Standard Report Format (narrative agents only)
+
+Structure your text response using these sections:
+- **Summary** — one paragraph: goal, what was accomplished, status.
+- **Actions Taken** — numbered list referencing tool calls and results.
+- **Key Decisions** — decisions with brief rationale (or "None required").
+- **Issues & Risks** — problems, unresolved concerns, or downstream risks (or "None").
+- **Deliverables Produced** — itemized list: \`**[Type]**: [ID] — [description]\`
+- **Self-Assessment** — Completeness X/10, Confidence X/10, Gaps.
+
+NOTE: If your output contract specifies a strict JSON schema, follow that schema instead of this report format.
+`.trim();
+const INJECTED_CONTEXT = `
+## Context Usage — Injected, Not Discovered
+
+Your execution brief above contains all the context you need to start:
+- **Corrections, gate feedback, preferences** — pre-loaded in prior sections.
+- **Authoritative upstream refs** — provided in your task prompt. Use them directly.
+- **Project orientation** — backlog summary, key decisions, and KB overview are injected above.
+
+**Rules:**
+- Context is preloaded. Start from injected context.
+- Use \`search_documents\` if you have a specific evidence gap.
+`.trim();
+const COORDINATOR_OUTPUT_CONTRACT = `
+## Output Contract — Coordinator Deliverables
+
+Coordinator deliverables are plain files written to \`/workspace/deliverables/\`.
+The orchestrator harvests + validates them after your turn completes.
+
+1. **Cross-cutting pages** — edit files under \`deliverables/pages/<slug>.md\`
+   (allowed slugs are in \`context.json.authority.mayWriteSlugs\`; the
+   biome rejects worker-owned slugs with a typed error).
+2. **Cross-unit consistency report** — write \`deliverables/consistency-report.json\`.
+   MANDATORY before you stop — the downstream reviewer reads it.
+3. **Narrow patches** to worker-owned pages — apply via \`edit\` /
+   \`md_edit\` directly. No separate record file.
+4. **Coordinator analysis** — write \`deliverables/analysis.json\` for
+   decisions and assumptions at the coordinator level.
+5. **Phase manifest** — write \`deliverables/manifest.json\` LAST, after every
+   page and JSON file is on disk. Without a valid manifest, your work
+   is not saved.
+
+Do not validate standards compliance or grade unit-worker content —
+that is the reviewer's job. Your output is consolidation + consistency.
+`.trim();
+const REVIEWER_CONTEXT_USAGE = `
+## Context Usage — Review Mode
+
+Reviewer path contracts are single-sourced in runtime \`/workspace/AGENTS.md\`.
+Do not infer or rewrite path conventions from memory.
+
+Reviewer inputs include template contract, deliverable pages under review,
+review-brief/coordinator-report when mounted, and upstream approved artifacts.
+Read review-brief first when present.
+
+**Rules:**
+- Read mounted files with \`read\` / \`glob\` — they are canonical.
+- Obey the template's \`scope\` and \`reviewDimensions\`. If a finding's remedy would require a different phase's agent to produce the fix, it is out of scope — drop it.
+- Write your verdict to \`deliverables/review.json\` matching the \`reviewer-output\` deliverable spec (\`verdict\` = \`approve\` | \`reject\` | \`abstain\`; structured \`summary\`, \`findings\`, optional \`suggestedEdits\`). The harvester validates against the spec — schema errors fail the gate.
+`.trim();
+const DEPLOYMENT_SCM_SAFETY = `
+## SCM Safety Rules
+
+- NEVER merge to the target branch — dry-run validation only.
+- NEVER push to any remote branch.
+- NEVER force push (\`git push --force\` or \`--force-with-lease\`).
+- NEVER amend commits.
+- NEVER rewrite history on shared branches.
+- NEVER resolve merge conflicts — abort and self-reject.
+- If anything goes wrong, self-reject with a \`:::TASK_REJECTION:::\` block.
+`.trim();
+const GIT_WORKFLOW = `
+## Git Workflow
+
+### Commit Message Format (Conventional Commits)
+
+\`\`\`
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+\`\`\`
+
+| Type | When |
+|------|------|
+| \`feat\` | New feature or capability |
+| \`fix\` | Bug fix |
+| \`refactor\` | Code restructuring without behavior change |
+| \`docs\` | Documentation only |
+| \`test\` | Adding or updating tests |
+| \`chore\` | Build, config, tooling changes |
+| \`perf\` | Performance improvement |
+
+- Subject line: max 72 characters, imperative mood ("add" not "added")
+- Scope: module, service, or area affected (e.g., \`auth\`, \`api\`, \`db\`)
+- Body: explain WHAT and WHY, not HOW (the diff shows how)
+
+### Staging Strategy
+
+- **Atomic commits**: Each commit should represent ONE logical change.
+- **Check before staging**: \`git status\` and \`git diff\` to review all changes.
+- **Stage related files together**: Don't mix unrelated changes in one commit.
+- **Never commit generated files**: Build output, lock files (unless intentional), \`.env\` files.
+
+### Rules
+
+- NEVER force-push — this destroys history.
+- NEVER amend commits that have been pushed.
+- NEVER commit secrets, credentials, or large binary files.
+- ALWAYS pull before push to avoid conflicts.
+`.trim();
+const GOVERNANCE_CONSTRAINTS = `
+## Pipeline Governance
+
+- You are operating within a governed pipeline run.
+- You may only submit candidate artifacts, patches, evidence, and review notes.
+- You may NOT directly mutate canonical workflow state, trigger phase transitions, or approve/merge artifacts.
+- All writes are proposals — the platform decides what becomes canonical after validation and approval.
+`.trim();
+const WORKSPACE_CONTEXT = `
+## Workspace & Platform Context
+
+Your workspace root is \`/workspace/\`.
+
+- Project code lives in \`/workspace/repos/<slug>/\`.
+- \`references/\` contains curated read-only evidence for this run.
+- \`inputs/\` contains invocation-scoped raw material (prompt payloads, schemas, retry instructions).
+- \`deliverables/\` is the writable area for pipeline deliverables.
+- \`attachments/\` contains user uploads (read-only).
+- \`.xema/\` and \`.opencode/\` are platform internals; do not modify them unless the task explicitly requires it.
+
+Use \`context.json\` authority to decide what is writable, and prefer targeted reads over broad repository scans.
+`.trim();
+const CATEGORY_SECTIONS = {
+    builder: [
+        EXECUTION_DISCIPLINE,
+        EVIDENCE_DISCIPLINE,
+        REPORT_VS_DELIVERABLES,
+        STANDARD_REPORT_FORMAT,
+        MEMORY_PRECEDENCE,
+        WORKSPACE_MATERIAL_MODEL,
+        CORRECTION_RECALL,
+        GATE_FEEDBACK,
+        FILE_FIRST_OUTPUT,
+        INJECTED_CONTEXT,
+        WORKSPACE_CONTEXT,
+        GIT_WORKFLOW,
+        GOVERNANCE_CONSTRAINTS,
+    ],
+    coordinator: [
+        EXECUTION_DISCIPLINE,
+        EVIDENCE_DISCIPLINE,
+        REPORT_VS_DELIVERABLES,
+        MEMORY_PRECEDENCE,
+        WORKSPACE_MATERIAL_MODEL,
+        CORRECTION_RECALL,
+        GATE_FEEDBACK,
+        FILE_FIRST_OUTPUT,
+        INJECTED_CONTEXT,
+        WORKSPACE_CONTEXT,
+        COORDINATOR_OUTPUT_CONTRACT,
+        GOVERNANCE_CONSTRAINTS,
+    ],
+    reviewer: [
+        EXECUTION_DISCIPLINE,
+        EVIDENCE_DISCIPLINE,
+        REPORT_VS_DELIVERABLES,
+        MEMORY_PRECEDENCE,
+        WORKSPACE_MATERIAL_MODEL,
+        REVIEWER_CONTEXT_USAGE,
+        WORKSPACE_CONTEXT,
+        GOVERNANCE_CONSTRAINTS,
+    ],
+    utility: [
+        EXECUTION_DISCIPLINE,
+        EVIDENCE_DISCIPLINE,
+        MEMORY_PRECEDENCE,
+        WORKSPACE_MATERIAL_MODEL,
+        WORKSPACE_CONTEXT,
+        GOVERNANCE_CONSTRAINTS,
+    ],
+    'pre-pipeline': [EXECUTION_DISCIPLINE, WORKSPACE_MATERIAL_MODEL, WORKSPACE_CONTEXT],
+    deployment: [
+        EXECUTION_DISCIPLINE,
+        EVIDENCE_DISCIPLINE,
+        REPORT_VS_DELIVERABLES,
+        STANDARD_REPORT_FORMAT,
+        WORKSPACE_MATERIAL_MODEL,
+        INJECTED_CONTEXT,
+        WORKSPACE_CONTEXT,
+        GIT_WORKFLOW,
+        DEPLOYMENT_SCM_SAFETY,
+        GOVERNANCE_CONSTRAINTS,
+    ],
+};
+const SYSTEM_LOCKED_KEYS = new Set([
+    'GOVERNANCE_CONSTRAINTS',
+    'DEPLOYMENT_SCM_SAFETY',
+]);
+exports.INSTRUCTION_SECTION_SEEDS = (() => {
+    const sectionMap = [
+        { key: 'EXECUTION_DISCIPLINE', content: EXECUTION_DISCIPLINE },
+        { key: 'EVIDENCE_DISCIPLINE', content: EVIDENCE_DISCIPLINE },
+        { key: 'REPORT_VS_DELIVERABLES', content: REPORT_VS_DELIVERABLES },
+        { key: 'STANDARD_REPORT_FORMAT', content: STANDARD_REPORT_FORMAT },
+        { key: 'MEMORY_PRECEDENCE', content: MEMORY_PRECEDENCE },
+        { key: 'WORKSPACE_MATERIAL_MODEL', content: WORKSPACE_MATERIAL_MODEL },
+        { key: 'CORRECTION_RECALL', content: CORRECTION_RECALL },
+        { key: 'GATE_FEEDBACK', content: GATE_FEEDBACK },
+        { key: 'FILE_FIRST_OUTPUT', content: FILE_FIRST_OUTPUT },
+        { key: 'INJECTED_CONTEXT', content: INJECTED_CONTEXT },
+        { key: 'COORDINATOR_OUTPUT_CONTRACT', content: COORDINATOR_OUTPUT_CONTRACT },
+        { key: 'REVIEWER_CONTEXT_USAGE', content: REVIEWER_CONTEXT_USAGE },
+        { key: 'DEPLOYMENT_SCM_SAFETY', content: DEPLOYMENT_SCM_SAFETY },
+        { key: 'GIT_WORKFLOW', content: GIT_WORKFLOW },
+        { key: 'WORKSPACE_CONTEXT', content: WORKSPACE_CONTEXT },
+        { key: 'GOVERNANCE_CONSTRAINTS', content: GOVERNANCE_CONSTRAINTS },
+    ];
+    const contentToKey = new Map(sectionMap.map((s) => [s.content, s.key]));
+    const sectionCategories = new Map();
+    for (const [category, sections] of Object.entries(CATEGORY_SECTIONS)) {
+        for (const sectionContent of sections) {
+            const key = contentToKey.get(sectionContent);
+            if (!key)
+                continue;
+            if (!sectionCategories.has(key)) {
+                sectionCategories.set(key, new Set());
+            }
+            sectionCategories.get(key).add(category);
+        }
+    }
+    return sectionMap.map((s) => ({
+        sectionKey: s.key,
+        content: s.content,
+        categories: [...(sectionCategories.get(s.key) ?? [])],
+        mutabilityTier: SYSTEM_LOCKED_KEYS.has(s.key)
+            ? 'system_locked'
+            : 'system_default',
+    }));
+})();
+//# sourceMappingURL=agents-md-sections.js.map

package/dist/lib/control-plane/agents-md-sections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents-md-sections.js","sourceRoot":"","sources":["../../../src/lib/control-plane/agents-md-sections.ts"],"names":[],"mappings":"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"}

package/dist/lib/control-plane/index.d.ts

@@ -0,0 +1,3 @@
+export { INSTRUCTION_SECTION_SEEDS } from './agents-md-sections';
+export type { InstructionSectionSeed, InstructionMutabilityTier, } from './agents-md-sections';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/control-plane/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/control-plane/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACjE,YAAY,EACV,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC"}

package/dist/lib/control-plane/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTRUCTION_SECTION_SEEDS = void 0;
+var agents_md_sections_1 = require("./agents-md-sections");
+Object.defineProperty(exports, "INSTRUCTION_SECTION_SEEDS", { enumerable: true, get: function () { return agents_md_sections_1.INSTRUCTION_SECTION_SEEDS; } });
+//# sourceMappingURL=index.js.map

package/dist/lib/control-plane/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/control-plane/index.ts"],"names":[],"mappings":";;;AASA,2DAAiE;AAAxD,+HAAA,yBAAyB,OAAA"}

package/dist/lib/direct-llm-invoker.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from '@nestjs/common';
+import type { OpenCodeConfig } from './opencode-config.interface';
+import type { DirectLlmProvider } from './modes/direct-llm.provider';
+import type { DirectLlmInput, DirectLlmResult } from './opencode.types';
+export interface DirectLlmDeps {
+    logger: Logger;
+    config: OpenCodeConfig;
+    directLlm: DirectLlmProvider;
+}
+export declare function executeDirectLlmToolLoop(input: DirectLlmInput, deps: DirectLlmDeps): Promise<DirectLlmResult>;
+//# sourceMappingURL=direct-llm-invoker.d.ts.map

package/dist/lib/direct-llm-invoker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"direct-llm-invoker.d.ts","sourceRoot":"","sources":["../../src/lib/direct-llm-invoker.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAOrE,OAAO,KAAK,EAEV,cAAc,EACd,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAO1B,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,cAAc,CAAC;IACvB,SAAS,EAAE,iBAAiB,CAAC;CAC9B;AAgHD,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,eAAe,CAAC,CAsN1B"}

package/dist/lib/direct-llm-invoker.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDirectLlmToolLoop = executeDirectLlmToolLoop;
+const llm_registry_client_1 = require("./llm-registry-client");
+const opencode_utils_1 = require("./opencode-utils");
+const openai_provider_1 = require("./providers/openai.provider");
+const anthropic_provider_1 = require("./providers/anthropic.provider");
+async function resolveGatewayOrDirectProvider(deps, registryConfig, orgId, projectId, phaseKey, runId) {
+    const { logger, config, directLlm } = deps;
+    if (config.llmRegistryApiUrl && config.serviceTokenProvider) {
+        const serviceToken = await config.serviceTokenProvider();
+        const providerTier = registryConfig.providerIsSystem
+            ? 'MANAGED'
+            : 'BYOK';
+        const providerId = registryConfig.opencodeProviderId ||
+            registryConfig.providerId ||
+            registryConfig.providerName ||
+            'unknown';
+        const gatewayTokenRes = await fetch(`${config.llmRegistryApiUrl.replace(/\/+$/, '')}/internal/gateway-tokens`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${serviceToken}`,
+                'X-Org-Id': orgId,
+                ...(projectId && { 'X-Project-Id': projectId }),
+            },
+            body: JSON.stringify({
+                userId: 'system',
+                providerId,
+                modelId: registryConfig.modelId,
+                providerTier,
+                groupCategory: runId ? 'PIPELINE' : phaseKey ? 'AGENT' : 'DIRECT',
+                metadata: {
+                    ...(runId && { pipelineRunId: runId }),
+                    ...(phaseKey && { phaseKey, agentKey: phaseKey }),
+                },
+            }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!gatewayTokenRes.ok) {
+            const errBody = await gatewayTokenRes
+                .text()
+                .catch(() => 'Unknown error');
+            throw new Error(`Failed to create gateway session for phase="${phaseKey}": ${gatewayTokenRes.status} ${errBody}`);
+        }
+        const { data: gatewaySession } = (await gatewayTokenRes.json());
+        logger.log(`Direct LLM: routing through gateway native proxy for phase="${phaseKey}" (provider=${providerId}, tier=${providerTier})`);
+        const isAnthropic = (registryConfig.providerName ?? '').toLowerCase() === 'anthropic';
+        if (isAnthropic) {
+            return new anthropic_provider_1.AnthropicProvider(gatewaySession.token, `${gatewaySession.nativeProxyUrl}/anthropic`, `gateway:anthropic`);
+        }
+        else {
+            return new openai_provider_1.OpenAiProvider(gatewaySession.token, `${gatewaySession.nativeProxyUrl}/openai/v1`, `gateway:${registryConfig.providerName ?? 'openai'}`);
+        }
+    }
+    return directLlm.getOrCreateRegistryProvider(registryConfig);
+}
+async function executeDirectLlmToolLoop(input, deps) {
+    const { logger } = deps;
+    const { systemPrompt, userPrompt, temperature, orgId, projectId, phaseKey, contextMessages, tools, toolChoice, toolExecutor, maxToolRounds = 10, signal, } = input;
+    if (signal?.aborted) {
+        throw new Error('runDirectLlm aborted before start');
+    }
+    if (tools?.length && !toolExecutor) {
+        throw new Error('runDirectLlm: `toolExecutor` callback is required when `tools` are provided');
+    }
+    if (!input.modelOverride && !phaseKey) {
+        throw new Error('runDirectLlm: `phaseKey` is required for LLM Registry model resolution. ' +
+            'Pass the pipeline phase key (e.g., "requirements", "engineering") to resolve the correct model, ' +
+            'or provide `modelOverride` to bypass registry resolution.');
+    }
+    const registryConfig = input.modelOverride ?? await (0, llm_registry_client_1.resolveFromRegistry)(logger, orgId, projectId, phaseKey);
+    const providerInstance = await resolveGatewayOrDirectProvider(deps, registryConfig, orgId, projectId, phaseKey, input.runId);
+    const hasTools = tools && tools.length > 0;
+    logger.log(`runDirectLlm: model="${registryConfig.modelId}" provider="${registryConfig.providerName}"` +
+        (hasTools
+            ? ` tools=[${tools.map((t) => t.function.name).join(',')}]`
+            : ''));
+    const messages = [{ role: 'system', content: systemPrompt }];
+    if (contextMessages?.length) {
+        for (const ctx of contextMessages) {
+            messages.push({ role: ctx.role, content: ctx.content });
+        }
+    }
+    messages.push({ role: 'user', content: userPrompt });
+    const cumulativeUsage = {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0,
+    };
+    let toolRounds = 0;
+    const toolFailureCounts = new Map();
+    const MAX_IDENTICAL_FAILURES = 1;
+    while (true) {
+        if (signal?.aborted) {
+            throw new Error('runDirectLlm aborted during tool-calling loop');
+        }
+        const response = await providerInstance.complete({
+            model: registryConfig.modelId,
+            messages,
+            temperature: temperature ?? 0.2,
+            ...(hasTools ? { tools: tools } : {}),
+            ...(hasTools && toolChoice !== undefined
+                ? { tool_choice: toolChoice }
+                : {}),
+        });
+        cumulativeUsage.promptTokens += response.usage.promptTokens;
+        cumulativeUsage.completionTokens += response.usage.completionTokens;
+        cumulativeUsage.totalTokens += response.usage.totalTokens;
+        if (!response.toolCalls?.length || !toolExecutor) {
+            logger.log(`runDirectLlm: completed in ${toolRounds} tool rounds, ` +
+                `${cumulativeUsage.totalTokens} total tokens, model="${response.model}"`);
+            return {
+                content: (0, opencode_utils_1.stripThinkingTags)(response.content),
+                model: response.model,
+                usage: cumulativeUsage,
+                toolRounds,
+            };
+        }
+        toolRounds++;
+        if (toolRounds > maxToolRounds) {
+            logger.warn(`runDirectLlm: hit maxToolRounds=${maxToolRounds}, returning last response`);
+            return {
+                content: (0, opencode_utils_1.stripThinkingTags)(response.content),
+                model: response.model,
+                usage: cumulativeUsage,
+                toolRounds,
+            };
+        }
+        logger.log(`runDirectLlm: round ${toolRounds} — model called ${response.toolCalls.length} tool(s): ` +
+            `[${response.toolCalls.map((tc) => tc.function.name).join(', ')}]`);
+        messages.push({
+            role: 'assistant',
+            content: response.content || null,
+            tool_calls: response.toolCalls,
+        });
+        const toolResults = await toolExecutor(response.toolCalls.map((tc) => ({
+            id: tc.id,
+            name: tc.function.name,
+            arguments: tc.function.arguments,
+        })));
+        let repeatedFailureDetected = false;
+        for (const result of toolResults) {
+            const matchingCall = response.toolCalls.find((tc) => tc.id === result.toolCallId);
+            if (result.isError && matchingCall) {
+                const failureKey = `${matchingCall.function.name}:${matchingCall.function.arguments}`;
+                const count = (toolFailureCounts.get(failureKey) ?? 0) + 1;
+                toolFailureCounts.set(failureKey, count);
+                if (count > MAX_IDENTICAL_FAILURES) {
+                    repeatedFailureDetected = true;
+                    logger.warn(`runDirectLlm: tool "${matchingCall.function.name}" failed ${count} times with identical args — injecting deterministic stop`);
+                }
+            }
+            else if (matchingCall) {
+                const successKey = `${matchingCall.function.name}:${matchingCall.function.arguments}`;
+                toolFailureCounts.delete(successKey);
+            }
+            messages.push({
+                role: 'tool',
+                tool_call_id: result.toolCallId,
+                content: result.isError
+                    ? `[ERROR] ${result.content}`
+                    : result.content,
+            });
+        }
+        if (repeatedFailureDetected) {
+            messages.push({
+                role: 'user',
+                content: '[SYSTEM] One or more tool calls failed repeatedly with identical arguments. ' +
+                    'Do NOT retry the same call. Either use different arguments, use a different tool, ' +
+                    'or proceed without the failing tool result.',
+            });
+        }
+    }
+}
+//# sourceMappingURL=direct-llm-invoker.js.map