opencode-orchestrator 1.5.4 → 1.6.1

package/README.md

@@ -6,7 +6,7 @@
   [![MIT License](https://img.shields.io/badge/license-MIT-red.svg)](LICENSE)
   [![npm](https://img.shields.io/npm/v/opencode-orchestrator.svg)](https://www.npmjs.com/package/opencode-orchestrator)
   <!-- VERSION:START -->
-  **Version:** `1.5.4`
+  **Version:** `1.6.1`
   <!-- VERSION:END -->
 </div>
 
@@ -84,6 +84,8 @@ Model selection follows normal OpenCode inheritance. The plugin does not force a
 
 Legacy top-level concurrency keys (`agentConcurrency`, `providerConcurrency`, `modelConcurrency`, `defaultConcurrency`) are still accepted for backward compatibility, but the plugin tuple is the preferred location.
 
+Plugin options are schema-described in `opencode-orchestrator.schema.json` (generated from the Zod source, shipped in the package) for editor autocomplete and validation. Invalid or missing option fields fall back to defaults rather than failing.
+
 ## 3. Run
 
 Inside OpenCode:
@@ -132,17 +134,32 @@ TUI commands:
 
 ## 4. How It Works
 
-```mermaid
-flowchart LR
-  U["/task input"] --> C["Commander"]
-  C --> P["Planner"]
-  C --> W["Worker pool"]
-  W --> R["Reviewer"]
-  P --> S["Mission state"]
-  W --> S
-  R --> V{"Verified?"}
-  V -- "no" --> C
-  V -- "yes" --> D["Done"]
+```text
+                    /task input
+                         |
+                         v
+                  +-------------+
+           +----->|  Commander  |
+           |      +------+------+
+           |             | delegates
+           |       +-----+------+
+           |       v            v
+           |  +---------+  +-------------+
+           |  | Planner |  | Worker pool |
+           |  +----+----+  +--+-------+--+
+           |       | writes   | impl  |
+           |       v          v       v
+           |  +------------------+  +----------+
+           |  |  Mission state   |  | Reviewer |
+           |  |   (.opencode/)   |  +----+-----+
+           |  +------------------+       |
+           |                             v
+           |  no (keep working)    +-----------+
+           +-----------------------+ Verified? |
+                                   +-----+-----+
+                                         | yes
+                                         v
+                                       Done
 ```
 
 | Agent | Purpose |
@@ -152,6 +169,14 @@ flowchart LR
 | Worker | Implements scoped file changes with isolated context. |
 | Reviewer | Checks completion evidence, tests, and integration risk. |
 
+The mission loop adjudicates continuation at the idle boundary rather than trusting a model's "done":
+
+1. Tool calls are observed to record changed files and verification runs; if files changed with no verification, the continuation prompt emphatically asks the model to run tests/build/lint and cite results (a nudge, never a hard block).
+2. Before declaring done the model is asked for a short self-account (scope fit, verification, residual risk).
+3. After sustained stagnation the loop stops blind retries and escalates: DECOMPOSE → RE-PLAN → ASK the user.
+
+Memory retrieval is role-aware (planners favor structure, workers favor exact matches, reviewers favor breadth) and memory notes carry a relevance `horizon`.
+
 Runtime evidence is written only when enabled:
 
 | Artifact | Purpose |
@@ -163,13 +188,22 @@ Runtime evidence is written only when enabled:
 
 ## 5. Developer Notes
 
+Local checks that mirror CI (`.github/workflows/ci.yml`), which gates every push and PR:
+
 ```bash
+# TypeScript
 npm run build
 npx tsc --noEmit
 npm test
-cargo test --workspace --all-targets
+
+# Rust (same gates CI enforces)
+cargo fmt --all --check
+cargo clippy --workspace --all-targets -- -D warnings
+cargo test --workspace
 ```
 
+Regenerate the plugin-options JSON Schema after changing option types: `npm run gen:schema`.
+
 Useful references:
 
 1. OpenCode plugins: https://opencode.ai/docs/plugins/

package/dist/agents/prompts/registry.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Prompt Registry
+ *
+ * Central composition seam for agent system prompts (Builder-inspired:
+ * `builder_app/src/system_prompt.rs` + `template_engine.rs`).
+ *
+ * Goals:
+ * 1. One place that joins prompt sections into a final system prompt.
+ * 2. Lightweight `{{var}}` interpolation for runtime context injection.
+ * 3. Model-tier "profiles" — a `compact` profile drops sections tagged
+ *    `verbose: true`, so weaker/smaller models can be given a leaner prompt
+ *    without duplicating prompt text. The default `standard` profile keeps
+ *    every section, so existing composed output is unchanged.
+ */
+export type PromptProfile = "standard" | "compact";
+/** A prompt fragment. Plain strings are always kept; tagged sections can be
+ *  dropped by profile. */
+export interface PromptSection {
+    body: string;
+    /** Dropped under the `compact` profile. */
+    verbose?: boolean;
+}
+export type PromptFragment = string | PromptSection;
+/**
+ * Replace `{{key}}` placeholders. Unknown keys are left intact, so calling with
+ * no vars is an identity transform on text that has no placeholders.
+ */
+export declare function interpolate(template: string, vars?: Record<string, string | number>): string;
+export interface ComposeOptions {
+    profile?: PromptProfile;
+    vars?: Record<string, string | number>;
+    separator?: string;
+}
+/**
+ * Compose a final prompt from ordered fragments. With the default `standard`
+ * profile, no vars, and the default separator this is exactly
+ * `fragments.join("\n\n")` — preserving existing prompt output byte-for-byte.
+ */
+export declare function composePrompt(fragments: PromptFragment[], options?: ComposeOptions): string;

package/dist/core/config/options-schema.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Schema-driven plugin options (Builder learning, Phase G).
+ *
+ * Builder derives one JSON Schema from its config types so the TOML, the schema
+ * file, and the editor UI never drift (`builder.schema.json` via schemars).
+ * Orchestrator models its plugin-tuple options as Zod here, which is both the
+ * runtime validator and the source for the exported JSON Schema.
+ *
+ * Parsing stays tolerant — invalid or missing fields fall back to defaults —
+ * to preserve the previous hand-rolled behavior exactly.
+ */
+import { z } from "zod";
+export declare const MissionLoopOptionsSchema: z.ZodCatch<z.ZodObject<{
+    ledger: z.ZodDefault<z.ZodCatch<z.ZodBoolean>>;
+    markdownMemory: z.ZodDefault<z.ZodCatch<z.ZodBoolean>>;
+    maxEvidenceEvents: z.ZodDefault<z.ZodCatch<z.ZodNumber>>;
+}, z.core.$strip>>;
+/** Full plugin-tuple options object — used to generate the public JSON Schema. */
+export declare const OrchestratorOptionsSchema: z.ZodObject<{
+    agentConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    defaultConcurrency: z.ZodOptional<z.ZodNumber>;
+    missionLoop: z.ZodOptional<z.ZodCatch<z.ZodObject<{
+        ledger: z.ZodDefault<z.ZodCatch<z.ZodBoolean>>;
+        markdownMemory: z.ZodDefault<z.ZodCatch<z.ZodBoolean>>;
+        maxEvidenceEvents: z.ZodDefault<z.ZodCatch<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+}, z.core.$loose>;
+/** Tolerant parse of the `missionLoop` option block. */
+export declare function parseMissionLoopOptions(value: unknown): {
+    ledger: boolean;
+    markdownMemory: boolean;
+    maxEvidenceEvents: number;
+};
+/** JSON Schema for editor autocomplete / external validation. */
+export declare function orchestratorOptionsJsonSchema(): unknown;

package/dist/core/knowledge/context-provider.d.ts

@@ -1,5 +1,5 @@
 export declare class KnowledgeContextProvider {
-    buildPrompt(directory: string, query: string): string | null;
+    buildPrompt(directory: string, query: string, role?: string): string | null;
     private collectMarkdownFiles;
     private walkDirectory;
     private indexKnowledge;

package/dist/core/knowledge/hybrid-search.d.ts

@@ -4,6 +4,7 @@
  */
 import type { TagIndexer } from "./tag-indexer.js";
 import type { GraphParser } from "./graph-parser.js";
+import { type EngineWeights } from "./retrieval-weights.js";
 /** Unified search result with provenance tracking. */
 export interface SearchResult {
     noteName: string;
@@ -24,7 +25,7 @@ export declare class HybridSearch {
     /**
      * Fuse lexical, tag, and graph rankings via RRF to produce a single list.
      */
-    search(query: string, maxResults?: number): SearchResult[];
+    search(query: string, maxResults?: number, weights?: EngineWeights): SearchResult[];
     /**
      * BM25-inspired term-frequency scoring across all indexed documents.
      * Approximates IDF via corpus size and document frequency.

package/dist/core/knowledge/retrieval-weights.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Role-aware retrieval weights and memory horizons.
+ *
+ * Builder learning (adoption assessment 2026-06-19, item E):
+ * - Context horizons classify a memory by how long it stays relevant
+ *   (`builder` MEMORY-SYSTEM deep dive: strategic / execution / closure).
+ * - The contextual reranker biases retrieval engines differently per role
+ *   (`unified_retrieval.rs`): planners favor structure, workers favor exact
+ *   lexical hits, reviewers favor breadth.
+ *
+ * Defaults are neutral (all weights = 1), so omitting a role leaves retrieval
+ * behavior unchanged.
+ */
+/** Relative multipliers applied to each hybrid-search engine's RRF contribution. */
+export interface EngineWeights {
+    lexical: number;
+    tag: number;
+    graph: number;
+}
+export declare const NEUTRAL_WEIGHTS: EngineWeights;
+/**
+ * Per-role engine bias. Roles are matched case-insensitively; unknown roles
+ * fall back to neutral weights.
+ */
+export declare const ROLE_WEIGHTS: Record<string, EngineWeights>;
+export declare function weightsForRole(role?: string | null): EngineWeights;
+/** Memory relevance horizon, derived from the memory level. */
+export type MemoryHorizon = "strategic" | "execution" | "closure";
+export declare function horizonForLevel(level: string): MemoryHorizon;

package/dist/core/loop/evidence.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Mission evidence store (Builder learning, adoption assessment item C).
+ *
+ * Builder treats a model's "done" as a candidate until the runtime has recorded
+ * enough evidence to close the task (`builder_app/src/plumbing_trace.rs`:
+ * changed files must be traced/verified). Orchestrator is a plugin and cannot
+ * own the per-turn loop, but it DOES own the mission-loop continuation decision.
+ *
+ * This module records, by observing `tool.execute.after`, which files a session
+ * changed and whether a verification command (test/build/lint) ran afterward. A
+ * "wiring gap" exists when files were changed with no later verification. The
+ * gap is surfaced as an emphatic continuation nudge — never a hard block — so it
+ * can never cause a false "not done" loop.
+ */
+export declare function recordChangedFile(sessionID: string, filePath: string, now?: number): void;
+export declare function recordVerification(sessionID: string, now?: number): void;
+/** Record evidence from a single observed tool call. */
+export declare function recordToolEvidence(sessionID: string, tool: string, args: Record<string, unknown> | undefined, now?: number): void;
+/** Number of changed files with no verification recorded after the last change. */
+export declare function getUnverifiedChangeCount(sessionID: string): number;
+export declare function getChangedFiles(sessionID: string): string[];
+export declare function clearEvidence(sessionID: string): void;

package/dist/core/loop/mission-loop.d.ts

@@ -9,6 +9,8 @@ import type { MissionLoopState, MissionLoopOptions } from "../../shared/loop/typ
 type MissionContinuationContext = {
     verificationSummary?: string;
     continuationReason?: string;
+    /** Files changed this mission with no verification recorded afterward. */
+    unverifiedChanges?: number;
 };
 type MissionContinuationInput = string | MissionContinuationContext;
 /**