@pellux/goodvibes-sdk 0.37.2 → 1.0.0

package/dist/platform/core/orchestrator.js

@@ -20,6 +20,7 @@ import { checkContextWindowPreflight, emitContextOverflowError, handlePostTurnCo
 import { createEmitterContext, estimateFreshTurnInputTokens, getCacheHitTracker, getIdempotencyStore, getSessionLineageTracker, normalizeUsage, requireConfigManager, requireProviderRegistry, } from './orchestrator-runtime.js';
 import { maybeEmitAdaptivePlannerDecision, prepareConversationForTurn, } from './orchestrator-turn-helpers.js';
 import { executeOrchestratorTurnLoop } from './orchestrator-turn-loop.js';
+import { recordTurnInjection, } from '../agents/turn-knowledge-injection.js';
 /** Delay (ms) before auto-spawning plan items if the model ends its turn without spawning them. */
 const AUTO_SPAWN_FALLBACK_DELAY_MS = 5_000;
 const THINKING_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
@@ -111,6 +112,19 @@ export class Orchestrator {
     permissionManager;
     getSystemPrompt;
     hookDispatcher;
+    /**
+     * Wave-5 (wo805) per-turn passive-injection state for the MAIN interactive session —
+     * see core/orchestrator-turn-loop.ts for the retrieval/budget wiring that reads and
+     * mutates these. `turnKnowledgeIdsAlreadySurfaced` has no spawn-time baseline (unlike
+     * an AgentRecord's `knowledgeInjections`) so it starts empty and grows monotonically
+     * for the life of this Orchestrator. `turnInjectionRing` backs the public
+     * `getTurnInjections()` accessor.
+     */
+    turnKnowledgeIdsAlreadySurfaced = new Set();
+    turnInjectionRing = [];
+    turnKnowledgeSequence = 0;
+    passiveKnowledgeInjectionBudgetTokens;
+    passiveKnowledgeInjectionRelevanceFloor;
     /**
      * Construct an Orchestrator using a named-options object.
      *
@@ -132,7 +146,9 @@ export class Orchestrator {
      * ```
      */
     constructor(options) {
-        const { conversation, getViewportHeight, scrollToEnd, toolRegistry, permissionManager, getSystemPrompt = () => '', hookDispatcher = null, flagManager = null, requestRender = null, runtimeBus = null, sessionId, services, } = options;
+        const { conversation, getViewportHeight, scrollToEnd, toolRegistry, permissionManager, getSystemPrompt = () => '', hookDispatcher = null, flagManager = null, requestRender = null, runtimeBus = null, sessionId, passiveKnowledgeInjectionBudgetTokens, passiveKnowledgeInjectionRelevanceFloor, services, } = options;
+        this.passiveKnowledgeInjectionBudgetTokens = passiveKnowledgeInjectionBudgetTokens;
+        this.passiveKnowledgeInjectionRelevanceFloor = passiveKnowledgeInjectionRelevanceFloor;
         this.sessionId = sessionId?.trim() || randomUUID();
         this.conversation = conversation;
         this.getViewportHeight = getViewportHeight;
@@ -250,6 +266,17 @@ export class Orchestrator {
     getSpinner() {
         return THINKING_SPINNER_FRAMES[this.thinkingFrame % THINKING_SPINNER_FRAMES.length];
     }
+    /**
+     * Wave-5 (wo805): bounded ring of per-turn passive-injection honesty records for the
+     * MAIN interactive session — the main-session counterpart to `AgentRecord.turnInjections`
+     * (wo801). There is no AgentRecord for the primary conversation, so this is the exact
+     * accessor a `/recall`-style renderer should read as the main-session default when no
+     * agent id is given. See agents/turn-knowledge-injection.ts for the record shape and
+     * recordTurnInjection for the ring-eviction policy (same bounded size as the agent path).
+     */
+    getTurnInjections() {
+        return this.turnInjectionRing;
+    }
     setSystemMessageRouter(router) {
         this.systemMessageRouter = router;
     }
@@ -505,6 +532,16 @@ export class Orchestrator {
             setLastInputTokens: (value) => { this.lastInputTokens = value; },
             markTurnFailed: () => { this._turnFailed = true; },
             usage: this.usage,
+            memoryRegistry: this.coreServices.memoryRegistry,
+            isPassiveKnowledgeInjectionEnabled: () => this.isPassiveKnowledgeInjectionEnabled(),
+            passiveKnowledgeInjectionBudgetTokens: this.passiveKnowledgeInjectionBudgetTokens,
+            passiveKnowledgeInjectionRelevanceFloor: this.passiveKnowledgeInjectionRelevanceFloor,
+            codeIndex: this.coreServices.codeIndex,
+            isPassiveCodeInjectionEnabled: () => this.isPassiveCodeInjectionEnabled(),
+            getAlreadyInjectedKnowledgeIds: () => this.getAlreadyInjectedKnowledgeIds(),
+            addInjectedKnowledgeIds: (ids) => { this.addInjectedKnowledgeIds(ids); },
+            recordTurnKnowledgeInjection: (record) => { this.recordTurnKnowledgeInjection(record); },
+            nextTurnKnowledgeSequence: () => this.nextTurnKnowledgeSequence(),
         });
     }
     /** Phase 3: Post-turn context maintenance (compaction, memory, plan updates). */
@@ -679,6 +716,54 @@ export class Orchestrator {
             return true;
         return this.flagManager.isEnabled('tool-result-reconciliation');
     }
+    /**
+     * Returns `true` when Wave-5 (wo801/wo805) per-turn passive knowledge injection is
+     * active for this session. Shares the SAME `agent-passive-knowledge-injection` flag as
+     * the agent path (agents/orchestrator-runner.ts) rather than a sibling main-session
+     * flag — the flag's own description already promises "the EVOLVING main-session
+     * conversation" coverage (see runtime/feature-flags/flags.ts), so wiring the main loop
+     * under the same id completes that promise instead of duplicating a second toggle for
+     * what is, from an operator's perspective, one feature.
+     *
+     * Defaults to `true` (flag `defaultState: 'enabled'`) when no flag manager has been
+     * wired in, matching {@link isReconciliationEnabled}'s convention.
+     */
+    isPassiveKnowledgeInjectionEnabled() {
+        if (this.flagManager === null)
+            return true;
+        return this.flagManager.isEnabled('agent-passive-knowledge-injection');
+    }
+    /**
+     * Stage B code injection is opt-in: the `agent-passive-code-injection` flag defaults OFF
+     * (so a null flagManager means OFF, unlike the memory flag above), AND the embedder's
+     * storage.codeIndexEnabled setting must be on. Both are re-read per turn.
+     */
+    isPassiveCodeInjectionEnabled() {
+        const flagOn = this.flagManager?.isEnabled('agent-passive-code-injection') ?? false;
+        const settingOn = this.coreServices.isCodeInjectionSettingEnabled?.() ?? true;
+        return flagOn && settingOn;
+    }
+    /**
+     * Wave-5 (wo805): ids never to re-surface in a later per-turn knowledge block. The main
+     * session has no spawn-time `AgentRecord.knowledgeInjections` baseline, so this starts
+     * empty and grows monotonically for the life of the Orchestrator.
+     */
+    getAlreadyInjectedKnowledgeIds() {
+        return [...this.turnKnowledgeIdsAlreadySurfaced];
+    }
+    /** Wave-5 (wo805): mark ids as surfaced so they are never listed twice this session. */
+    addInjectedKnowledgeIds(ids) {
+        for (const id of ids)
+            this.turnKnowledgeIdsAlreadySurfaced.add(id);
+    }
+    /** Wave-5 (wo805): append one honesty record to the bounded ring behind {@link getTurnInjections}. */
+    recordTurnKnowledgeInjection(record) {
+        this.turnInjectionRing = recordTurnInjection(this.turnInjectionRing, record);
+    }
+    /** Wave-5 (wo805): monotonic per-Orchestrator-lifetime sequence number for TurnInjectionRecord.turn. */
+    nextTurnKnowledgeSequence() {
+        return ++this.turnKnowledgeSequence;
+    }
     /**
      * Reconcile unresolved tool calls at turn end.
      *
@@ -712,6 +797,9 @@ export class Orchestrator {
             runtimeBus: this.runtimeBus,
             sessionId: this.sessionId,
             emitterContext: (id) => createEmitterContext(this.sessionId, id),
+            onToolExecuted: this.coreServices.codeIndexReindexScheduler
+                ? (toolName, args, success) => this.coreServices.codeIndexReindexScheduler.onToolExecuted(toolName, args, success)
+                : undefined,
         }, turnId, calls);
     }
 }

package/dist/platform/core/plan-decomposition.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Agent-driven goal decomposition for the planner.
+ *
+ * This module is the model-decomposition counterpart to the deterministic
+ * heuristic path in `plan-proposal.ts`. Given a goal, it drives a bounded,
+ * READ-ONLY planning agent (through the injected `DecompositionRunner` seam —
+ * this module never imports the agent machinery, so it stays in `core` and is
+ * fully unit-testable with a stubbed runner), parses and STRICTLY validates
+ * the agent's structured output, and produces a `PlanProposal` tagged with
+ * honest provenance.
+ *
+ * Failure honesty is the whole point: a spawn error, a timeout/cancellation,
+ * or output that is still malformed after ONE repair attempt all fall back to
+ * the existing heuristic `singleItemProposal` path, tagged
+ * `decomposedBy: 'heuristic'` with a `fallbackReason`. The heuristic path is
+ * reused verbatim — `singleItemProposal`/`assemblePlanProposal` are never
+ * modified — so their existing byte-for-byte test expectations are preserved;
+ * provenance is layered on afterward.
+ *
+ * The module NEVER performs surgery on agent output to force it to validate:
+ * a proposal is accepted only when `assemblePlanProposal` reports ZERO issues
+ * (no dangling dependency, no dependency cycle, no unresolved phase). Anything
+ * short of that is one repair attempt and then an honest fallback — never a
+ * silent edit that drops or rewrites the agent's work items.
+ */
+import { AdaptivePlanner } from './adaptive-planner.js';
+import type { PlannerInputs, DecompositionGate } from './adaptive-planner.js';
+import { type PlanProposal, type PlanProposalIssue, type RawDecomposition, type DecompositionAgentUsage } from './plan-proposal.js';
+/** A phase in the agent's decomposition. Optional across the contract — items
+ *  may share an implicit single phase. */
+export interface DecompositionAgentPhase {
+    title: string;
+    description?: string;
+}
+/**
+ * A single work item in the agent's decomposition.
+ *
+ * `ordinal` fixes a stable execution order independent of array position.
+ * `dependsOn` entries may be either other items' titles or their ordinals
+ * (as a number or numeric string) — both are resolved to titles before the
+ * proposal is assembled.
+ */
+export interface DecompositionAgentItem {
+    title: string;
+    brief: string;
+    ordinal: number;
+    phase?: string;
+    dependsOn?: Array<string | number>;
+    suggestedArchetype?: string;
+    likelyFiles?: string[];
+    verification?: string[];
+    canRunConcurrently?: boolean;
+    needsReview?: boolean;
+}
+/** The full JSON object a planning agent emits. */
+export interface DecompositionAgentOutput {
+    phases?: DecompositionAgentPhase[];
+    items: DecompositionAgentItem[];
+    /** Extra explicit edges; `{from, to}` reads "from depends on to". */
+    dependencies?: Array<{
+        from: string | number;
+        to: string | number;
+    }>;
+    notes?: string[];
+    risks?: string[];
+}
+/** Hard bounds on a planning-agent run. */
+export interface DecompositionBounds {
+    /** Maximum agent turns before the run is stopped. */
+    maxTurns: number;
+    /** Total token budget; exceeding it stops the run. */
+    tokenCeiling: number;
+    /** Wall-clock timeout in ms; exceeding it cancels the run. */
+    wallTimeoutMs: number;
+}
+export interface DecompositionRunnerRequest {
+    goal: string;
+    workingDir: string;
+    systemPrompt: string;
+    userPrompt: string;
+    bounds: DecompositionBounds;
+    /** Which attempt this is; `'repair'` prompts include prior validation errors. */
+    attempt: 'initial' | 'repair';
+}
+/**
+ * Terminal status of a planning-agent run.
+ * - `completed` — the agent finished and produced final output text.
+ * - `cancelled` — the run was stopped: an external kill, the wall-clock
+ *   timeout firing, or the token ceiling being crossed all collapse to this.
+ * - `failed`    — the agent could not be spawned or errored mid-run.
+ */
+export type DecompositionRunStatus = 'completed' | 'cancelled' | 'failed';
+export interface DecompositionRunResult {
+    status: DecompositionRunStatus;
+    /** The agent's final output text (empty when it never produced any). */
+    output: string;
+    usage?: DecompositionAgentUsage | undefined;
+    elapsedMs: number;
+    /** Error detail for `failed`, or a stop detail for `cancelled` (e.g. 'wall-timeout'). */
+    detail?: string | undefined;
+    agentId?: string | undefined;
+}
+export interface DecompositionRunner {
+    run(request: DecompositionRunnerRequest): Promise<DecompositionRunResult>;
+}
+export interface DecomposeGoalConstraints {
+    /** Concurrency capacity the plan should respect, if the caller set one. */
+    capacity?: number | undefined;
+    /** Dollar budget for the workstream, if the caller set one. */
+    budgetUsd?: number | undefined;
+}
+export interface DecomposeGoalRequest {
+    goal: string;
+    workingDir: string;
+    constraints?: DecomposeGoalConstraints | undefined;
+    /** Optional free-form user context handed to the planning agent. */
+    userContext?: string | undefined;
+}
+export interface DecompositionServiceConfig {
+    mode: 'agent' | 'heuristic';
+    bounds: DecompositionBounds;
+}
+/** An honest, machine-readable record of how a decomposition resolved. */
+export type DecompositionOutcome = {
+    kind: 'agent';
+    itemCount: number;
+    repaired: boolean;
+    usage?: DecompositionAgentUsage | undefined;
+    costUsd?: number | undefined;
+    elapsedMs: number;
+} | {
+    kind: 'heuristic-configured';
+} | {
+    kind: 'gate-declined';
+    reasonCode: DecompositionGate['reasonCode'];
+} | {
+    kind: 'fallback';
+    reason: string;
+    usage?: DecompositionAgentUsage | undefined;
+    elapsedMs?: number | undefined;
+};
+export interface DecomposeGoalDeps {
+    /** Optional token→dollars estimator; when absent, `agentCostUsd` stays undefined. */
+    estimateCostUsd?: ((usage: DecompositionAgentUsage) => number | undefined) | undefined;
+    /** Optional honest-event sink, invoked exactly once per decomposition. */
+    onOutcome?: ((outcome: DecompositionOutcome) => void) | undefined;
+}
+export interface DecomposeGoalResult {
+    proposal: PlanProposal;
+    gate: DecompositionGate;
+    issues: PlanProposalIssue[];
+    outcome: DecompositionOutcome;
+}
+export interface ParsedDecomposition {
+    ok: boolean;
+    raw?: RawDecomposition | undefined;
+    notes?: string[] | undefined;
+    errors: string[];
+}
+/**
+ * Parse + strictly validate a planning agent's output text into a
+ * `RawDecomposition` the assembler can consume. Never throws; every problem is
+ * accumulated into `errors` so a single repair prompt can address them all at
+ * once. Structural rejects: unparseable JSON, empty/absent items array, empty
+ * item title/brief, non-finite ordinal, empty phase title.
+ */
+export declare function parseDecomposition(text: string): ParsedDecomposition;
+/**
+ * Map a validated `DecompositionAgentOutput` into the `RawDecomposition` shape
+ * `assemblePlanProposal` consumes. Items are ordered by `ordinal` (stable on
+ * ties). Every referenced phase is materialized so the assembler never has to
+ * synthesize an "Unphased" bucket — an unresolved phase from here would be a
+ * real bug, not agent sloppiness. Ordinal-based dependency references are
+ * resolved to titles so the assembler's title resolver handles them uniformly.
+ */
+export declare function toRawDecomposition(output: DecompositionAgentOutput): RawDecomposition;
+/**
+ * Build the system prompt for the read-only planning agent. It is explicit
+ * about the exact JSON contract and about the read-only posture (the agent's
+ * tool set already excludes write/edit/exec; this reinforces intent).
+ */
+export declare function buildPlannerSystemPrompt(): string;
+/**
+ * Decompose a goal into a `PlanProposal`, honestly tagged with provenance.
+ *
+ * Control flow:
+ *  1. `config.mode === 'heuristic'` → the configured heuristic path (no agent).
+ *  2. The planner's decompose gate declines → honest single-item (no agent).
+ *  3. No runner available → heuristic fallback (reason: no runtime).
+ *  4. Agent path: run → parse → strict-validate → (assemble; issues===0 ?
+ *     accept : ONE repair attempt) → accept-or-fallback. Spawn error,
+ *     cancellation (kill / wall-timeout / token ceiling), or still-invalid
+ *     output after repair all fall back to the heuristic path with a reason.
+ */
+export declare function decomposeGoal(request: DecomposeGoalRequest, planner: AdaptivePlanner, inputs: PlannerInputs, config: DecompositionServiceConfig, runner: DecompositionRunner | null, deps?: DecomposeGoalDeps): Promise<DecomposeGoalResult>;
+//# sourceMappingURL=plan-decomposition.d.ts.map

package/dist/platform/core/plan-decomposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-decomposition.d.ts","sourceRoot":"","sources":["../../../src/platform/core/plan-decomposition.ts"],"names":[],"mappings":"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"}