pullfrog 0.1.5 → 0.1.7

package/dist/agents/postRun.d.ts

@@ -8,6 +8,17 @@ import { type AgentResult, type AgentRunContext, type AgentUsage, type PostRunIs
  *
  * the gate is anchored to `hadProgressComment` so silent runs (non-issue
  * events, dispatcher skipped seeding) don't fire a nudge there's no UI for.
+ *
+ * `Review` and `IncrementalReview` have different valid exits:
+ *   - Review: only `create_pull_request_review` counts. `report_progress` is
+ *     not a substitute — a Review run that exits with just a summary comment
+ *     has produced nothing reviewable on the PR. matches the hard-fail
+ *     message at `expected = "create_pull_request_review"` below.
+ *   - IncrementalReview: `report_progress` is a legitimate "no review
+ *     warranted" exit, so either toolState flag short-circuits.
+ * splitting per mode also closes the bypass where a subagent (e.g. a
+ * `task`-dispatched `reviewfrog` lens) calls `report_progress` and silences
+ * the gate even though the orchestrator never submitted a review.
  */
 export declare function getUnsubmittedReview(toolState: ToolState): "Review" | "IncrementalReview" | null;
 /**
@@ -56,6 +67,16 @@ export declare function buildPostRunPrompt(issues: PostRunIssues): string;
  * the file is the single source of truth — there is no separate MCP tool
  * call. the server reads the file at end-of-run and persists any edits to
  * `Repo.learnings`.
+ *
+ * the prompt copy is shaped by repo-wide audits of the actual content the
+ * agent has been writing (issue #619 in pullfrog/app). recurring failure
+ * modes the framing pushes back on:
+ *  - massive multi-paragraph "bullets" that are really mini-articles
+ *  - PR-/review-/commit-/date-anchored facts that decay within weeks
+ *  - rediscovery of pullfrog-tool quirks that belong in tool descriptions,
+ *    not per-repo learnings
+ *  - sections growing into giant flat lists with no internal structure,
+ *    forcing future runs to read kilobytes to find one fact
  */
 export declare function buildLearningsReflectionPrompt(filePath: string): string;
 /**

package/dist/agents/sessionLabeler.d.ts

@@ -36,32 +36,52 @@ export declare const ORCHESTRATOR_LABEL = "orchestrator";
  */
 export declare function deriveLabelFromTaskInput(input: TaskDispatchInput): string;
 /**
- * Stateful tracker mapping sessionIDs to human labels.
+ * Stateful tracker mapping subagent activity back to human-readable labels.
  *
- * Lifecycle:
- *   - First call to `labelFor()` returns ORCHESTRATOR_LABEL and binds that
- *     sessionID to it. Every subsequent event from that session gets the
- *     same label.
- *   - When the orchestrator emits a Task tool_use, the harness calls
- *     `recordTaskDispatch()` to push the dispatch's derived label onto a
- *     pending FIFO queue.
- *   - The next previously-unseen sessionID consumes the head of the queue.
- *   - If `labelFor()` is called for a new session with an empty queue
- *     (e.g. a subagent emitted events before the parent's tool_use was
- *     parsed, or the runtime spawned a session we didn't expect), the
- *     labeler falls back to `subagent#N` so log lines remain attributable.
+ * Two attribution channels are supported because the runtimes differ:
+ *
+ *   - **OpenCode** spawns each subagent as its own opencode `Session` with
+ *     a distinct `sessionID`. The harness records each Task dispatch into a
+ *     pending FIFO queue; the next previously-unseen sessionID consumes the
+ *     head of the queue and binds it to that label.
+ *
+ *   - **Claude Code** runs subagents inside the orchestrator's session — they
+ *     all share `session_id` — and instead stamps every subagent message with
+ *     `parent_tool_use_id` pointing at the Agent tool_use id that spawned them.
+ *     The harness binds each Agent tool_use id to its dispatched label up
+ *     front, then `labelFor` looks the label up directly when an event arrives
+ *     carrying that `parent_tool_use_id`.
+ *
+ * `labelFor(sessionID, parentToolUseId?)` accepts both: when
+ * `parentToolUseId` is set and known it short-circuits to the direct mapping;
+ * otherwise it falls through to the FIFO/sessionID path.
  */
 export declare class SessionLabeler {
     private readonly labels;
+    private readonly labelsByToolUseId;
     private readonly pendingLabels;
     private fallbackCounter;
-    recordTaskDispatch(input: TaskDispatchInput): string;
     /**
-     * Return a label for the given sessionID. Binds on first call.
-     * Pass undefined/empty for events that lack a session id — the caller
-     * gets ORCHESTRATOR_LABEL so the line is still attributable.
+     * Record a Task/Agent tool dispatch.
+     *
+     * @param input  Task tool input — used to derive the lens label.
+     * @param toolUseId  Optional Agent tool_use id. When provided, future events
+     *                   carrying `parent_tool_use_id === toolUseId` resolve
+     *                   directly to this label without consuming the FIFO queue
+     *                   (Claude path). Always also pushed to the FIFO queue so
+     *                   the OpenCode path still works when toolUseId is absent.
+     */
+    recordTaskDispatch(input: TaskDispatchInput, toolUseId?: string | null): string;
+    /**
+     * Return a label for the given event.
+     *
+     * @param sessionID         Session id from the event (OpenCode: per-session;
+     *                          Claude: shared across orchestrator + subagents).
+     * @param parentToolUseId   Claude's `parent_tool_use_id` — non-null on
+     *                          subagent messages. When set and known, takes
+     *                          priority over the FIFO/sessionID path.
      */
-    labelFor(sessionID: string | undefined | null): string;
+    labelFor(sessionID: string | undefined | null, parentToolUseId?: string | null): string;
     /** number of distinct sessions seen so far (for diagnostics) */
     size(): number;
     /** all (sessionID, label) pairs, oldest first */

package/dist/agents/subagentModels.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Derive a cheaper subagent model override from the orchestrator's resolved
+ * model spec.
+ *
+ * This is a pure registry lookup: every alias in `action/models.ts` declares
+ * its own `subagentModel` (alias key in the same provider). At runtime we
+ * reverse-lookup the orchestrator's resolved slug to find the alias that
+ * produced it, follow the `subagentModel` pointer, and return the target
+ * alias's resolve / openRouterResolve depending on which route the
+ * orchestrator was using.
+ *
+ * Returns `{ reviewer: undefined }` when the orchestrator's alias has no
+ * `subagentModel` (e.g. it's already at a sufficiently cheap tier, or its
+ * provider doesn't have a clean cheaper-but-capable sibling). See models.ts
+ * for the wiring + per-provider rationale.
+ */
+export declare function deriveSubagentModels(orchestratorSpec: string | undefined): {
+    reviewer: string | undefined;
+};