@caupulican/pi-adaptative 0.80.97 → 0.80.99

package/CHANGELOG.md

@@ -1,3 +1,56 @@
+## [0.80.99] - 2026-07-02
+
+### Added
+
+- Added code-writing workers (G2 full): with `workerDelegation.writeEnabled` plus a `writePaths`
+  scope, a delegated worker may emit structured file actions (write/edit) that the RUNNER applies
+  through the capability envelope's path scope — an out-of-scope or denied path is refused with a
+  reason and downgrades the result to blocked (a partial change can never look like clean success),
+  and a write without the grant is ignored and flagged. `workerDelegation.maxConcurrent` (1-3)
+  replaces the single-flight limit. The read-only scout contract is unchanged when writes are off.
+- Added speculative muscle-retry on executor turns: when an executor-routed turn ends without a
+  successful run_toolkit_script execution, pi retries once on the same executor with the brain's
+  refined instruction injected (the brain warms while the muscle tries, so the retry costs only
+  when the muscle actually missed); visible in the router decision as executor_speculative_retry.
+- Added gate-outcome history (G8): a bounded 50-entry history of tool-gate outcomes replaces the
+  latest-only record (getGateOutcomeHistory()), and the three remaining autonomy telemetry types
+  (gateOutcome, workerRequest, approvalRequest) now emit at their honest sites.
+- Added per-turn foreground capability envelopes (G7): each turn derives an observe-only envelope
+  (capabilities mapped from active tools, path scope = cwd, usd bound from the cost guard),
+  surfaced as a one-line /context observation and via getForegroundEnvelope().
+- Added capability-scaled goal-continuation budgets (G9): lean-class models (16-32k) now cap
+  autonomous continuation at 2 turns / 5 minutes; below 16k stays gated off, full class unchanged.
+
+## [0.80.98] - 2026-07-02
+
+### Added
+
+- Added the executor lane (G16): configure `modelRouter.executorModel` (or assign it in one step
+  from /fitness -> "Toolkit executor") and command-shaped prompts that score a deterministic
+  Level-0 EXACT hit on the toolkit registry route the whole turn to the local executor — with the
+  judge skipped (nothing to judge), the tool surface capability-filtered to the executor's own
+  class, and `run_toolkit_script` exempted from the cheap-tier mutation escalation ONLY on these
+  routes (its own danger gate still applies; any other mutating tool still escalates). Ambiguous
+  requests never route here — they stay with the main model and the reflex brain.
+- Added workspace research sources (G1): the autonomous research lane now grounds itself in the
+  repo — a bounded ripgrep collector derives terms from the goal text and feeds pointer-first
+  sources (repo-relative path, line, <=200-char excerpt; never file bodies) into the research
+  prompt and the evidence bundle, with the synthesis anchors always preserved. Best-effort: no
+  ripgrep or no matches reproduces the previous behavior exactly.
+- Added real evidence strength to the learning gate (G6): a bounded persistent observation store
+  counts how often the same lesson (layer + normalized summary) is re-observed across passes and
+  sessions, so `minObservations` now gates on truth — the first observation proposals, repeated
+  ones can auto-apply.
+- Added autonomy telemetry emission (G3): route decisions, research/worker lane outcomes, and
+  learning decisions now emit redacted, bounded events (ids/codes/numbers only — never prompt or
+  memory text) as `autonomy-telemetry` session entries.
+- Added execution-time capability-envelope path enforcement and worker request persistence (G2
+  prerequisites): a tool wrapped in an envelope scope structurally refuses out-of-scope paths at
+  the moment it runs (deny-wins, escape-proof), and every worker result persists its originating
+  request (instructions, route, envelope) for audit.
+- Added digest-served telemetry: the /context curation line now reports how many brain digests
+  were actually rendered into GC stubs on real turns — the pays-for-itself number.
+
 ## [0.80.97] - 2026-07-02
 
 ## [0.80.96] - 2026-07-02

package/dist/core/agent-session.d.ts

@@ -1,8 +1,8 @@
 import type { Agent, AgentEvent, AgentMessage, AgentState, AgentTool, ThinkingLevel } from "@caupulican/pi-agent-core";
 import type { CacheRetention, ImageContent, Message, Model, StopReason, TextContent, Usage } from "@caupulican/pi-ai";
-import type { CapabilityEnvelope, EvidenceBundle, LearningDecision, WorkerResult } from "./autonomy/contracts.ts";
+import type { CapabilityEnvelope, EvidenceBundle, LearningDecision, WorkerRequest, WorkerResult } from "./autonomy/contracts.ts";
 import { type LaneRecord } from "./autonomy/lane-tracker.ts";
-import type { AutonomyDiagnosticSnapshot, AutonomyStatusSnapshot } from "./autonomy/status.ts";
+import type { AutonomyDiagnosticSnapshot, AutonomyStatusSnapshot, GateOutcomeHistoryEntry } from "./autonomy/status.ts";
 import { type BashResult } from "./bash-executor.ts";
 import { type CompactionResult } from "./compaction/index.ts";
 import { type CurationTelemetrySnapshot } from "./context/brain-curator.ts";
@@ -32,6 +32,7 @@ import { type StoredFitnessReport } from "./models/fitness-store.ts";
 import { type PromptTemplate } from "./prompt-templates.ts";
 import { type ModelFitnessReport } from "./research/model-fitness.ts";
 import { type ResearchRunResult } from "./research/research-runner.ts";
+import { collectWorkspaceSources } from "./research/workspace-collector.ts";
 import type { ResourceLoader } from "./resource-loader.ts";
 import type { BranchSummaryEntry, SessionManager } from "./session-manager.ts";
 import { type ResourceProfileFilterSettings, type SettingsManager } from "./settings-manager.ts";
@@ -141,6 +142,12 @@ export interface AgentSessionConfig {
     };
     /** Session start event metadata emitted when extensions bind to this runtime. */
     sessionStartEvent?: SessionStartEvent;
+    /**
+     * Pointer-first workspace source collector for the autonomous research lane. Injected in unit
+     * tests so they don't spawn a real ripgrep child (which would escape fake timers); production
+     * defaults to the real, best-effort collector.
+     */
+    collectWorkspaceSources?: typeof collectWorkspaceSources;
 }
 export interface ExtensionBindings {
     uiContext?: ExtensionUIContext;
@@ -322,8 +329,6 @@ export declare class AgentSession {
     private readonly _laneTracker;
     /** Session-lifetime abort for in-flight research passes (same pattern as _reflectionAbort). */
     private readonly _researchLaneAbort;
-    /** Single-flight guard: at most one delegated worker runs at a time per session. */
-    private _isWorkerDelegationRunning;
     /** Session-lifetime abort for in-flight delegated workers. */
     private readonly _workerDelegationAbort;
     /**
@@ -357,11 +362,14 @@ export declare class AgentSession {
     private _pendingBashMessages;
     private _extensionRunner;
     private _turnIndex;
+    /** G7: per-turn foreground CapabilityEnvelope auto-built for visibility (observe-only; not enforced). */
+    private _currentForegroundEnvelope?;
     private _resourceLoader;
     private _customTools;
     private _baseToolDefinitions;
     private _cwd;
     private _agentDir;
+    private _collectWorkspaceSources;
     private _extensionRunnerRef?;
     private _initialActiveToolNames?;
     private _allowedToolNames?;
@@ -390,6 +398,8 @@ export declare class AgentSession {
     private _isModelRouterRetry;
     private _lastModelRouterDecision?;
     private _lastAutonomyGateOutcome?;
+    /** G8: bounded (cap {@link GATE_OUTCOME_HISTORY_LIMIT}) history of gate outcomes; tail is latest. */
+    private readonly _gateOutcomeHistory;
     private _lastModelRouterSkipReason?;
     private _lastModelRouterIntent?;
     /** Lazily-built skill curator (#32) over `<agentDir>/skills`. */
@@ -721,6 +731,15 @@ export declare class AgentSession {
      * Returns the names of tools currently set on the agent.
      */
     getActiveToolNames(): string[];
+    /** G7: build a foreground {@link CapabilityEnvelope} from the live session state (active tools, cwd, cost ceiling). */
+    private _buildForegroundEnvelopeFromState;
+    /**
+     * G7: (re)build the foreground envelope for the current turn. Visibility only -- the foreground
+     * envelope is NOT enforced this round. Best-effort: never throws into the turn.
+     */
+    private _refreshForegroundEnvelope;
+    /** G7: the auto-constructed foreground envelope for the current/most-recent turn (visibility only). */
+    getForegroundEnvelope(): CapabilityEnvelope | undefined;
     /**
      * Get all configured tools with name, description, parameter schema, prompt guidelines, and source metadata.
      */
@@ -781,6 +800,10 @@ export declare class AgentSession {
     private _rebuildSystemPrompt;
     private _runAgentPrompt;
     private _isModelAvailableAndAuthed;
+    private _resolveExecutorRoute;
+    /** True if a run_toolkit_script tool result since `fromIndex` actually EXECUTED (not error/ambiguous). */
+    private _executorTurnExecutedScript;
+    private _buildExecutorRefinedPrompt;
     private _resolveModelRouterTurnRoute;
     private _resolveModelRouterModelForIntent;
     private _resolveConfiguredTierModel;
@@ -1182,7 +1205,25 @@ export declare class AgentSession {
     getEvidenceBundleSnapshots(): EvidenceBundle[];
     /** Live lane records tracked by this process (running and terminal). */
     getLaneRecords(): LaneRecord[];
-    saveWorkerResultSnapshot(result: WorkerResult): string;
+    /**
+     * G3: bounded autonomy-telemetry sink. Passes the whole event through {@link redactTelemetryValue}
+     * (the taxonomy's redaction contract) before storing it, so a secret that leaked into a payload
+     * field never lands in the session log. Observe-only: a failure here can never surface into the
+     * turn it is measuring, so the whole body is swallowed. Payloads MUST stay small (ids, codes,
+     * numbers) — never prompt/summary text; callers own that discipline.
+     */
+    private _emitAutonomyTelemetry;
+    /**
+     * G8: single sink for a gate outcome. Keeps the latest-outcome getter behavior identical (the
+     * full {@link GateOutcome} still lands in `_lastAutonomyGateOutcome`), and additionally appends a
+     * bounded codes-only entry to {@link _gateOutcomeHistory} (oldest evicted at
+     * {@link GATE_OUTCOME_HISTORY_LIMIT}) and emits the `gate_outcome` telemetry event. The history
+     * tail therefore always mirrors the latest outcome. Only called with an active envelope.
+     */
+    private _recordGateOutcome;
+    /** G8: copies of the bounded gate-outcome history, oldest first, latest last. */
+    getGateOutcomeHistory(): GateOutcomeHistoryEntry[];
+    saveWorkerResultSnapshot(result: WorkerResult, request?: WorkerRequest): string;
     getWorkerResultSnapshots(): WorkerResult[];
     saveLearningDecisionSnapshot(decision: LearningDecision): string;
     getLearningDecisionSnapshots(): LearningDecision[];