goatchain 0.0.24 → 0.0.26

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

@@ -24,6 +24,6 @@
  * ```
  */
 export { ToolAccessController } from './controller';
-export { EXPLORE_POLICY, GENERAL_PURPOSE_POLICY, PLAN_MODE_POLICY, } from './policies';
+export { EXPLORE_POLICY, GENERAL_PURPOSE_POLICY, PLAN_MODE_POLICY, SELF_REFLECTION_POLICY, } from './policies';
 export type { ToolAccessMode, ToolAccessPolicy, ToolValidationResult } from './types';
 export { assertReadOnlyBashCommand, FORBIDDEN_PATTERNS, isReadOnlyBashCommand, READ_ONLY_COMMANDS, } from './validators';

package/dist/lib/access-control/policies.d.ts

@@ -38,3 +38,13 @@ export declare const EXPLORE_POLICY: ToolAccessPolicy;
  * Full access to all tools except Task (to prevent infinite recursion).
  */
 export declare const GENERAL_PURPOSE_POLICY: ToolAccessPolicy;
+/**
+ * Self-Reflection Critic Subagent Policy
+ *
+ * Read-only access for verifying the main agent's work, plus the
+ * ReflectionDecision tool for recording the final verdict.
+ *
+ * Similar to EXPLORE_POLICY but also allows WebSearch, WebFetch,
+ * and the ReflectionDecision tool.
+ */
+export declare const SELF_REFLECTION_POLICY: ToolAccessPolicy;

package/dist/lib/session-blob.d.ts

@@ -0,0 +1,50 @@
+export declare const IMAGE_CACHE_DIR = "image-cache";
+export declare const BLOB_DIR = "blobs";
+export declare const META_DIR = "meta";
+export declare const BLOB_TTL_MS: number;
+export declare const FILE_ID_PATTERN: RegExp;
+export type SessionBlobWriteResult = Readonly<{
+    fileId: string;
+    filePath: string;
+    lineCount: number;
+    sha256: string;
+    byteSize: number;
+}>;
+export type BlobLogger = (event: string, payload?: unknown) => void;
+export declare function resolveStateDir(): string;
+export declare function resolveSessionCacheDir(sessionId: string): string;
+export declare function resolveBlobPathFromFileId(fileId: string, sessionId: string): string;
+export declare function normalizeSessionId(raw: unknown): string | null;
+export declare function parseBlobPathInfo(absPath: string): {
+    sessionId: string;
+    fileId: string;
+} | null;
+export declare function writeSessionBlob(opts: Readonly<{
+    content: string;
+    sessionId: string;
+    source?: string;
+    logger?: BlobLogger;
+}>): Promise<SessionBlobWriteResult | null>;
+/**
+ * Write text to a session-scoped blob with automatic TTL cleanup.
+ * Returns null if content is empty, sessionId is invalid, or write fails.
+ */
+export declare function cacheTextToSessionBlob(opts: Readonly<{
+    content: string;
+    sessionId?: string;
+    source?: string;
+    logger?: BlobLogger;
+}>): Promise<SessionBlobWriteResult | null>;
+export declare function deleteSessionBlobByPath(absPath: string, logger?: BlobLogger): Promise<boolean>;
+export declare function relocateSessionBlobPath(absPath: string, targetSessionId: string): Promise<string | null>;
+export declare function readBlobMeta(sessionId: string, fileId: string): Promise<Record<string, unknown> | null>;
+export declare function cleanupSessionCache(sessionId: string, logger?: BlobLogger): Promise<void>;
+export declare function cleanupExpiredSessionCaches(opts?: Readonly<{
+    ttlMs?: number;
+    logger?: BlobLogger;
+}>): Promise<void>;
+/**
+ * Reset the internal cleanup timestamp. Only useful for tests.
+ * @internal
+ */
+export declare function _resetCleanupTimer(): void;

package/dist/mcp-client/manager.d.ts

@@ -18,5 +18,7 @@ export declare class McpServerManager {
         error?: string;
     }>;
     getClient(serverId: string): McpClient | undefined;
+    /** Replace hyphens with underscores so tool names stay consistent. */
+    private static sanitizeName;
     private resolveToolName;
 }

package/dist/middleware/attachmentMiddleware.d.ts

@@ -0,0 +1,34 @@
+import type { Middleware } from '../agent/middleware';
+import type { AgentLoopState } from '../agent/types';
+export interface AttachmentMiddlewareOptions {
+    /** Whether the model supports vision (images). Default: `false` */
+    supportsVision?: boolean;
+    /** Whether the model supports native PDFs / documents. Default: `false` */
+    supportsPdfs?: boolean;
+}
+/**
+ * Create a middleware that injects image/PDF attachment data into the
+ * conversation as user messages before each model call.
+ *
+ * **Design:**
+ *
+ * - The Read tool stores binary data in `structuredContent.attachments`.
+ * - The Session layer splits this into two metadata fields:
+ *   - `_toolAttachmentRefs` (small, persisted in checkpoint)
+ *   - `_toolAttachmentData` (large base64, transient / in-memory only)
+ * - This middleware, on each iteration:
+ *   1. Finds the **trailing unanswered** tool messages (no assistant response after them)
+ *   2. Collects matching attachment data (re-reads files if data is missing after resume)
+ *   3. Injects a single **user message** with image/document content blocks
+ *   4. Evicts old attachment data to free memory
+ *
+ * **Registration order:** Must be the **last** (innermost) middleware so that
+ * context compression runs first on clean messages.
+ *
+ * @example
+ * ```typescript
+ * const mw = createAttachmentMiddleware({ supportsVision: true, supportsPdfs: true }) // explicitly enable
+ * agent.use(mw, 'attachment') // register last
+ * ```
+ */
+export declare function createAttachmentMiddleware(options?: AttachmentMiddlewareOptions): Middleware<AgentLoopState>;

package/dist/middleware/commitModeMiddleware.d.ts

@@ -34,7 +34,7 @@ export interface CommitModeMiddlewareOptions {
      */
     allowBehindRemote?: boolean;
     /**
-     * Middleware name (default: 'commit-mode')
+     * Middleware name (default: 'commit_mode')
      */
     name?: string;
     /**

package/dist/middleware/contextCompressionMiddleware.d.ts

@@ -16,7 +16,7 @@ export interface ContextCompressionOptions {
     /**
      * Number of recent conversation turns to always protect (default: 2).
      * A turn is a user message + assistant response pair.
-     * The first turn and last N turns will always be preserved for summary compression.
+     * The last N turns will always be preserved from summary compression.
      * Tool compression ignores this setting and only preserves tool results from
      * the most recent completed turn.
      */
@@ -49,6 +49,21 @@ export interface ContextCompressionOptions {
      * Default: 'compression-logs.jsonl'
      */
     logFilePath?: string;
+    /**
+     * Token limit of the model used for summarization.
+     * Used to determine when chunked summarization is needed.
+     * When the content to summarize exceeds this limit, the middleware
+     * automatically splits it into chunks and summarizes sequentially.
+     * Defaults to maxTokens if not specified.
+     */
+    summaryModelMaxTokens?: number;
+    /**
+     * Maximum characters per individual message when formatting for summary.
+     * More aggressive truncation reduces the chance of needing chunked summarization.
+     * Applies to tool outputs, user messages, and assistant messages.
+     * Default: 3000
+     */
+    maxMessageCharsForSummary?: number;
 }
 /**
  * Options for manual compression.
@@ -85,6 +100,17 @@ export interface ManualCompressionOptions {
      * Default: 'compression-logs.jsonl'
      */
     logFilePath?: string;
+    /**
+     * Token limit of the model used for summarization.
+     * Used to determine when chunked summarization is needed.
+     * Defaults to 128000 if not specified.
+     */
+    summaryModelMaxTokens?: number;
+    /**
+     * Maximum characters per individual message when formatting for summary.
+     * Default: 3000
+     */
+    maxMessageCharsForSummary?: number;
 }
 /**
  * Result of manual compression.
@@ -126,7 +152,7 @@ export interface CompressionStats {
  * This middleware automatically compresses conversation history using a two-stage strategy:
  *
  * **Stage 1 (Summary Compression) - Triggers at 80% of maxTokens:**
- * - Summarizes messages between first turn and last N turns
+ * - Summarizes all messages before the last N protected turns
  * - Generates rolling summary (AI merges old + new summaries)
  * - Removes entire messages from array
  * - Injects summary into system message

package/dist/middleware/envInfoMiddleware.d.ts

@@ -37,6 +37,12 @@ export interface EnvInfoMiddlewareOptions {
      * Defaults to true.
      */
     respectGitignore?: boolean;
+    /**
+     * Model name/ID to display in environment information.
+     * Can be a string or a function that returns a string.
+     * Use a function to support dynamic model switching at runtime.
+     */
+    modelName?: string | (() => string);
 }
 /**
  * Create an environment information middleware.

package/dist/middleware/gitUtils.d.ts

@@ -37,6 +37,10 @@ export declare function getStagedFiles(cwd: string): StagedFileInfo[];
  * Check if there are any unstaged changes (including untracked files)
  */
 export declare function hasUnstagedChanges(cwd: string): boolean;
+/**
+ * Append Co-Authored-By trailer to a commit message if not already present.
+ */
+export declare function appendCoAuthoredBy(message: string): string;
 /**
  * Create a git commit with the given message
  * @param message - Commit message

package/dist/middleware/longRunningMiddleware.d.ts

@@ -0,0 +1,100 @@
+import type { Middleware } from '../agent/middleware';
+import type { AgentLoopState } from '../agent/types';
+import type { ModelClient } from '../model';
+import type { CompletionAssessor } from '../session/completion/types';
+import type { ToolRegistry } from '../tool';
+/**
+ * Options for self-reflection critic subagent execution.
+ *
+ * When provided to `createLongRunningMiddleware`, the middleware will
+ * directly create and run a `SelfReflectionCritic` subagent in the
+ * `__afterResponse` phase (no dependency on `createParallelSubagentMiddleware`).
+ */
+export interface SelfReflectionOptions {
+    /**
+     * Model client for the critic subagent.
+     * Usually the same model as the main agent.
+     */
+    model: ModelClient;
+    /**
+     * Tool registry for the critic subagent.
+     * Tools are filtered by the critic's read-only access policy.
+     */
+    globalToolRegistry: ToolRegistry;
+    /**
+     * Maximum length of the agent's response to include in the review context.
+     * Longer responses are truncated to save tokens.
+     *
+     * @default 4000
+     */
+    maxResponseLength?: number;
+    /**
+     * Enable debug logging for the critic subagent.
+     *
+     * @default false
+     */
+    debug?: boolean;
+}
+/**
+ * Options for the long_running middleware.
+ */
+export interface LongRunningMiddlewareOptions {
+    /**
+     * Optional custom completion assessor.
+     *
+     * When provided, runs before the self-reflection critic. If it says
+     * "not complete", a follow-up message is injected and the critic is
+     * skipped. If it says "complete" (or is omitted), the critic runs.
+     *
+     * Use this for cheap, deterministic checks (e.g. file-existence,
+     * regex-based quality gates) that can short-circuit before the
+     * expensive critic subagent.
+     */
+    assessor?: CompletionAssessor;
+    /**
+     * Enable the self-reflection critic subagent.
+     *
+     * Provide a `SelfReflectionOptions` object with `model` and `globalToolRegistry`
+     * to enable direct critic subagent execution within the middleware.
+     * No dependency on `createParallelSubagentMiddleware`.
+     *
+     * Omit or set to `undefined` to disable.
+     */
+    selfReflection?: SelfReflectionOptions;
+    /**
+     * Maximum number of follow-up rounds before force-stopping.
+     * Prevents infinite loops when the assessor keeps saying "not complete".
+     *
+     * @default 3
+     */
+    maxFollowUpRounds?: number;
+}
+/**
+ * Create a long_running middleware that drives loop continuation.
+ *
+ * The core mechanism is the **self-reflection critic subagent**: when the
+ * main agent stops calling tools, the middleware spawns a read-only critic
+ * to review the agent's work and decide whether it is truly complete.
+ *
+ * Optionally, a custom `assessor` can run before the critic for cheap,
+ * deterministic checks (e.g. file-existence, regex-based quality gates).
+ *
+ * @example
+ * ```ts
+ * // Self-reflection critic (recommended)
+ * agent.use(createLongRunningMiddleware({
+ *   selfReflection: { model, globalToolRegistry: tools },
+ *   maxFollowUpRounds: 3,
+ * }))
+ *
+ * // With a custom pre-check assessor + critic
+ * agent.use(createLongRunningMiddleware({
+ *   assessor: new MyQualityGateAssessor(),
+ *   selfReflection: { model, globalToolRegistry: tools },
+ * }))
+ *
+ * // Pass-through (no assessment, same as not using the middleware)
+ * agent.use(createLongRunningMiddleware())
+ * ```
+ */
+export declare function createLongRunningMiddleware(options?: LongRunningMiddlewareOptions): Middleware<AgentLoopState>;

package/dist/middleware/parallelSubagentMiddleware.d.ts

@@ -32,7 +32,7 @@ export interface ParallelSubagentMiddlewareOptions {
      */
     debug?: boolean;
     /**
-     * 可选：middleware 名称（默认: 'parallel-subagent'）
+     * 可选：middleware 名称（默认: 'parallel_subagent'）
      */
     name?: string;
 }
@@ -43,7 +43,7 @@ export interface ParallelSubagentMiddlewareOptions {
  * 1. 自动创建并注册 TaskTool（包含 subagent 定义和 executor）
  * 2. 启用并行执行模式：当 LLM 同时调用多个 Task 工具时自动并行执行
  *
- * TaskTool 会被注册为 `<middlewareName>_Task`，例如 `parallel-subagent_Task`
+ * TaskTool 会被注册为 `<middlewareName>_Task`，例如 `parallel_subagent_Task`
  *
  * @example 使用默认 executor（推荐）
  * ```typescript

package/dist/middleware/planModeMiddleware.d.ts

@@ -17,7 +17,7 @@ export interface PlanModeMiddlewareOptions {
     insertEveryIteration?: boolean;
     /**
      * Custom name for this middleware (optional).
-     * If not provided, defaults to 'plan-mode'.
+     * If not provided, defaults to 'plan_mode'.
      */
     name?: string;
     /**
@@ -49,7 +49,7 @@ export interface PlanModeMiddlewareOptions {
  * execution, prohibiting file edits and encouraging thoughtful analysis.
  *
  * When registered via `agent.use()`, this middleware also automatically registers
- * the `ExitPlanMode` tool with a namespace prefix (e.g., `plan-mode_ExitPlanMode`).
+ * the `ExitPlanMode` tool with a namespace prefix (e.g., `plan_mode_ExitPlanMode`).
  *
  * @param options - Configuration options for the middleware
  * @returns A middleware function that injects plan mode instructions
@@ -62,7 +62,7 @@ export interface PlanModeMiddlewareOptions {
  *   model,
  *   middleware: [createPlanModeMiddleware()],
  * })
- * // Tools automatically registered: 'plan-mode_ExitPlanMode'
+ * // Tools automatically registered: 'plan_mode_ExitPlanMode'
  * ```
  *
  * @example Custom configuration

package/dist/middleware/reviewMiddleware.d.ts

@@ -30,7 +30,7 @@ export interface ReviewModeMiddlewareOptions {
      */
     includeStats?: boolean;
     /**
-     * Middleware name (default: 'review-mode')
+     * Middleware name (default: 'review_mode')
      */
     name?: string;
     /**

package/dist/middleware/skillsMiddleware.d.ts

@@ -34,6 +34,14 @@ export interface SkillsMiddlewareOptions {
      * If not provided, defaults to 'skills'.
      */
     name?: string;
+    /**
+     * Skills to force-activate regardless of tool calls in message history.
+     * These skills will always be injected into the system message.
+     *
+     * Can be a static array or a function that returns an array for dynamic resolution.
+     * Use a function to support server-side state that may change at runtime.
+     */
+    forcedSkills?: string[] | (() => string[]);
 }
 /**
  * Parsed skill from SKILL.md file with YAML frontmatter.

package/dist/model/anthropic/createAnthropicAdapter.d.ts

@@ -43,7 +43,7 @@ interface AnthropicToolUseBlock {
 interface AnthropicToolResultBlock {
     type: 'tool_result';
     tool_use_id: string;
-    content: string;
+    content: string | Array<AnthropicTextBlock | AnthropicImageBlock | AnthropicDocumentBlock>;
     is_error?: boolean;
 }
 interface AnthropicThinkingBlock {

package/dist/model/codex/createCodexAdapter.d.ts

@@ -28,7 +28,7 @@ export interface CodexAdapterOptions {
     accountId?: string | (() => string | Promise<string>);
     /**
      * Default model ID to use when not specified in the request.
-     * @example 'gpt-5.1-codex-max', 'gpt-5.2-codex', 'gpt-5.1-codex-mini'
+     * @example 'gpt-5.3-codex', 'gpt-5.2-codex', 'gpt-5.1-codex-mini'
      */
     defaultModelId?: string;
     /**

package/dist/model/index.d.ts

@@ -9,6 +9,8 @@ export { createGeminiAdapter } from './gemini/createGeminiAdapter';
 export type { GeminiAdapterOptions } from './gemini/createGeminiAdapter';
 export { createOpenAIAdapter } from './openai/createOpenAIAdapter';
 export type { OpenAIAdapterOptions } from './openai/createOpenAIAdapter';
+export { createOpenAIResponsesAdapter } from './openai/createOpenAIResponsesAdapter';
+export type { OpenAIResponsesAdapterOptions } from './openai/createOpenAIResponsesAdapter';
 export type { ModelClient, ModelDeltaChunk, ModelId, ModelRef, ModelRequest, ModelRunResult, ModelStopReason, ModelStreamEvent, OpenAITool, ProviderId, } from './types';
 export { RetryPolicy } from './utils/retry';
 export type { JitterStrategy, RetryPolicyOptions, RetryStrategy } from './utils/retry';

package/dist/model/openai/createOpenAIResponsesAdapter.d.ts

@@ -0,0 +1,28 @@
+import type { ModelAdapter } from '../adapter';
+export interface OpenAIResponsesAdapterOptions {
+    /**
+     * OpenAI SDK baseURL override.
+     *
+     * Examples:
+     * - Official: https://api.openai.com/v1
+     * - Proxy gateway base URL: https://your-proxy.example.com/v1
+     *
+     * If you pass a URL that already ends with `/responses`, we treat it as an exact
+     * Responses endpoint and will force all requests to hit it as-is.
+     */
+    baseUrl?: string;
+    /**
+     * OpenAI API key (recommended). If not provided, falls back to env `OPENAI_API_KEY`.
+     */
+    apiKey?: string | (() => string | undefined);
+    /**
+     * Default model ID to use when not specified in routing.
+     */
+    defaultModelId?: string;
+    /**
+     * Optional headers.
+     */
+    organization?: string;
+    project?: string;
+}
+export declare function createOpenAIResponsesAdapter(options?: OpenAIResponsesAdapterOptions): ModelAdapter;

package/dist/session/completion/composite.d.ts

@@ -0,0 +1,25 @@
+import type { CompletionAssessment, CompletionAssessor, CompletionContext } from './types';
+/**
+ * Composite completion assessor.
+ *
+ * Runs multiple assessors in priority order. The first assessor that
+ * returns `isComplete: false` wins (fail-fast). If all assessors say
+ * "complete", the task is considered done.
+ *
+ * Recommended ordering: cheapest/fastest assessors first.
+ *
+ * @example
+ * ```typescript
+ * const assessor = new CompositeAssessor([
+ *   new RuleBasedAssessor(),      // zero cost
+ *   new TodoBasedAssessor(),      // zero cost
+ *   new SelfReflectionAssessor({ model }),  // optional, adds cost
+ * ])
+ * ```
+ */
+export declare class CompositeAssessor implements CompletionAssessor {
+    readonly name: string;
+    private readonly assessors;
+    constructor(assessors: CompletionAssessor[]);
+    assess(context: CompletionContext): Promise<CompletionAssessment>;
+}

package/dist/session/completion/index.d.ts

@@ -0,0 +1,8 @@
+export type { CompletionAssessment, CompletionAssessor, CompletionContext, } from './types';
+export { CompositeAssessor } from './composite';
+export { RuleBasedAssessor } from './strategies/rule-based';
+export { TodoBasedAssessor } from './strategies/todo-based';
+export { SelfReflectionAssessor } from './strategies/self-reflection';
+export type { SelfReflectionAssessorOptions } from './strategies/self-reflection';
+export { ReflectionDecisionTool } from './strategies/reflection-decision-tool';
+export type { ReflectionDecision, ReflectionDecisionCallback } from './strategies/reflection-decision-tool';

package/dist/session/completion/strategies/reflection-decision-tool.d.ts

@@ -0,0 +1,51 @@
+import type { CallToolResult, ToolInputSchema } from '../../../types';
+import type { ToolExecutionContext } from '../../../tool/types';
+import { BaseTool } from '../../../tool/base';
+/**
+ * Parsed decision from the ReflectionDecisionTool.
+ */
+export interface ReflectionDecision {
+    /** Whether the task is truly complete from the user's perspective */
+    isComplete: boolean;
+    /** Explanation of why the reviewer reached this conclusion */
+    reason: string;
+    /** Potential issues found (even if isComplete is true, for informational purposes) */
+    potentialIssues?: string[];
+    /** Follow-up questions the user would likely ask (only meaningful when isComplete is false) */
+    followUpQuestions?: string[];
+}
+/**
+ * Callback invoked when the critic subagent makes a decision.
+ */
+export type ReflectionDecisionCallback = (decision: ReflectionDecision) => void;
+/**
+ * Get the latest decision recorded by the ReflectionDecisionTool.
+ * Returns `null` if no decision has been recorded (or it was cleared).
+ */
+export declare function getLatestReflectionDecision(): ReflectionDecision | null;
+/**
+ * Clear the stored decision. Should be called at the start of a new
+ * reflection cycle (round 0) to avoid stale data from previous runs.
+ */
+export declare function clearLatestReflectionDecision(): void;
+/**
+ * ReflectionDecisionTool - the critic subagent's verdict tool.
+ *
+ * This tool is the **only** way for the reflection subagent to conclude its
+ * review. When called, it records the structured decision (complete / not
+ * complete, potential issues, follow-up questions) and signals the outer
+ * `SelfReflectionAssessor` via both:
+ * 1. A module-level store (always) — so the assessor can read the verdict
+ * 2. An optional callback (if provided) — for custom integrations
+ *
+ * The tool forces the model to make an explicit, structured decision rather
+ * than embedding its verdict in free-form text.
+ */
+export declare class ReflectionDecisionTool extends BaseTool {
+    readonly name = "ReflectionDecision";
+    readonly description = "Record your final review decision. You MUST call this tool exactly once to conclude your reflection.\n\nRules:\n- isComplete: true ONLY if you found ZERO issues and the work is perfect\n- isComplete: false if you found ANY issue at all, no matter how minor\n- reason: brief explanation referencing specific evidence from your verification\n- potentialIssues: every issue you found. If this list is non-empty, isComplete MUST be false\n- followUpQuestions: specific actionable instructions for the agent to fix each issue (required when isComplete is false)\n\nABSOLUTE RULE: potentialIssues non-empty => isComplete MUST be false. No exceptions.";
+    readonly parameters: ToolInputSchema;
+    private readonly _callback;
+    constructor(callback?: ReflectionDecisionCallback);
+    execute(args: Record<string, unknown>, _ctx: ToolExecutionContext): Promise<CallToolResult>;
+}

package/dist/session/completion/strategies/rule-based.d.ts

@@ -0,0 +1,16 @@
+import type { CompletionAssessment, CompletionAssessor, CompletionContext } from '../types';
+/**
+ * Rule-based completion assessor.
+ *
+ * Uses zero-cost pattern matching on the model's response and state to
+ * detect obviously incomplete work:
+ * - Response truncated by model (lastModelStopReason === 'length')
+ * - Response contains phrases suggesting incomplete work
+ *
+ * This assessor is intentionally conservative -- it only flags clear signals
+ * of incompleteness to avoid false positives.
+ */
+export declare class RuleBasedAssessor implements CompletionAssessor {
+    readonly name = "RuleBasedAssessor";
+    assess(context: CompletionContext): Promise<CompletionAssessment>;
+}

package/dist/session/completion/strategies/self-reflection.d.ts

@@ -0,0 +1,54 @@
+import type { CompletionAssessment, CompletionAssessor, CompletionContext } from '../types';
+/**
+ * Options for the SelfReflectionAssessor.
+ */
+export interface SelfReflectionAssessorOptions {
+    /**
+     * Maximum length of the agent's response to include in the review context.
+     * Longer responses are truncated to save tokens.
+     *
+     * @default 4000
+     */
+    maxResponseLength?: number;
+}
+/**
+ * Self-reflection completion assessor (thin trigger).
+ *
+ * Instead of running its own subagent, this assessor composes a
+ * follow-up message that instructs the main agent to invoke the
+ * `SelfReflectionCritic` subagent via the Task tool. The critic
+ * subagent is defined in `src/subagent/self-reflection-critic.ts`
+ * and must be registered with the parallel subagent middleware.
+ *
+ * Flow:
+ * 1. On first assessment (followUpRound === 0), the assessor returns
+ *    `{ isComplete: false, followUpMessage }` -- the message tells
+ *    the main agent to call `Task(subagent_type: 'SelfReflectionCritic', ...)`
+ * 2. The main agent invokes the critic subagent, which searches the
+ *    codebase, verifies claims, and records its verdict via the
+ *    `ReflectionDecision` tool.
+ * 3. On round 1, the assessor checks the critic's **actual verdict**:
+ *    - If the critic listed ANY issues (even if isComplete=true), the
+ *      assessor overrides to NOT COMPLETE and forwards issues to the agent.
+ *    - Only if the critic said COMPLETE with zero issues (or wasn't
+ *      reached) does the assessor return `{ isComplete: true }`.
+ * 4. On round 2+, the assessor trusts the agent's follow-up corrections.
+ */
+export declare class SelfReflectionAssessor implements CompletionAssessor {
+    readonly name = "SelfReflectionAssessor";
+    private readonly maxResponseLength;
+    private static readonly LOG_PREFIX;
+    constructor(options?: SelfReflectionAssessorOptions);
+    private _log;
+    assess(context: CompletionContext): Promise<CompletionAssessment>;
+    /**
+     * Build a follow-up message from the critic's decision when it found issues.
+     * This message is injected back into the conversation so the main agent
+     * can address the problems before the task is marked complete.
+     */
+    private _buildCriticFollowUp;
+    /**
+     * Build the review context that will be passed to the critic subagent.
+     */
+    private _buildReviewPrompt;
+}

package/dist/session/completion/strategies/todo-based.d.ts

@@ -0,0 +1,17 @@
+import type { CompletionAssessment, CompletionAssessor, CompletionContext } from '../types';
+/**
+ * Todo-based completion assessor.
+ *
+ * Checks the TodoWriteTool's structured state to determine if all tasks
+ * have been completed. This is cheap and reliable because it uses
+ * data that the agent itself created.
+ *
+ * Assessment logic:
+ * - If there are no todos, assume complete (agent may not have used todos)
+ * - If all todos are 'completed', task is complete
+ * - If any todos are 'pending' or 'in_progress', task is not complete
+ */
+export declare class TodoBasedAssessor implements CompletionAssessor {
+    readonly name = "TodoBasedAssessor";
+    assess(context: CompletionContext): Promise<CompletionAssessment>;
+}