@piagent/platform 1.6.0 → 1.7.1

package/packages/piagent-core/prompts/be-to-fe.md

@@ -26,13 +26,7 @@ Flow:
    - BE scout: read-only.
    - FE implementation: source-write.
    - Auth/data migration/external provider: high-risk, ask before implementation.
-4. Use bounded read-only subagents only when BE/FE mapping has independent lanes worth the extra token/tool cost:
-   - `piagent-scout` maps backend contract read-only;
-   - `piagent-scout` maps frontend touchpoints read-only;
-   - builtin `context-builder` may create handoff context when the BE→FE mapping touches multiple journeys/forms/contracts;
-   - `piagent-planner` produces the FE implementation plan when the contract touches multiple layers;
-   - `piagent-reviewer` reviews diff/verification after implementation.
-   Continue single-agent if subagents are unavailable, the task is tiny, or requirements are unresolved.
+4. Keep BE scouting and FE implementation in the parent by default. At most one fresh read-only `piagent-scout` may map either the BE contract or FE touchpoints only when runtime evidence proves two independent lanes and at least 30% projected total token savings after handoff/merge. Never launch two scouts, delegate FE writes/planning/review, inherit the parent transcript, or retry a deterministic helper failure.
 5. Scout backend contract read-only:
    - controller/route/handler;
    - request/response DTO/schema;
@@ -53,7 +47,7 @@ Flow:
    - route/page/component/form;
    - tests/e2e.
 9. Call `piagent_task_start` exactly once before FE source writes and reuse an active contract.
-10. Implement FE only with one writer by default.
+10. Implement FE in the parent; helper workers are disabled.
 11. Run every exact command returned in `task.verifyCommands` after the latest mutation. For a normal default plan, review the final diff and mark only its review step done with `piagent_task_progress`.
 12. Let runtime hooks record context, verification, trace, and final-gate state. Use recovery tools only if the runtime reports missing evidence.
 13. Do not paste full test/build/tool logs into chat or final output. Summarize the signal and quote only relevant failing lines.

package/packages/piagent-core/prompts/plan.md

@@ -17,7 +17,7 @@ Rules:
 4. Read `.pi/project-context.md`; if it is missing or still pending, recommend `/onboard-project run` before implementation.
 5. Read required context.
 6. Identify protected paths and external/high-risk actions.
-7. Decide whether subagents are useful enough to justify extra token/tool cost. If the bundled `pi-subagents` parent skill is available, use it for delegation patterns and safety boundaries. If `pi-subagents`/`subagent(...)` is available, use `piagent-scout` for independent read-only repo/spec mapping before medium/large plans. Use builtin `context-builder` when the task needs a handoff context/meta-prompt. Use `piagent-oracle` for architecture/risk challenge when the decision is non-obvious. Continue single-agent for tiny plans or unavailable subagent tooling.
+7. Keep planning in the parent. At most one fresh read-only helper may run only when runtime evidence proves two independent workstreams, no dependency on later parent output, and at least 30% projected total token savings after transfer/merge. Never delegate implementation, fork parent history, retry a deterministic helper failure, or add a helper only for review quality.
 8. Produce a compact task tree/workPlan with exact files, commands, owner role, review lenses, and verify gates.
 9. Do not implement yet unless the user explicitly asks.
 

package/packages/piagent-core/prompts/platform-improve.md

@@ -23,18 +23,14 @@ Flow:
 1. Use runtime automatic intake for a bounded platform change. If runtime pauses for broad, high-risk, or ambiguous scope, call `piagent_task_start` exactly once with project-relative path/glob scope and reuse an active contract.
 2. Read the narrow current implementation, its tests, and the relevant policy/schema/docs. Runtime hooks inject bounded navigation context when useful.
 3. Treat memory and generated context as advisory; verify against current files.
-4. Use bounded subagents only when independent lanes justify their extra token/tool cost:
-   - use `piagent-scout` for read-only code/package mapping;
-   - use `piagent-planner` for a plan when multiple modules are affected;
-   - use `piagent-reviewer` for diff, docs, and verification review;
-   - continue single-agent for small, localized edits.
+4. Keep platform analysis, planning, implementation, and review in the parent. At most one fresh read-only helper may map a genuinely independent lane only when runtime evidence projects at least 30% lower total tokens after handoff/merge. Do not delegate writes, fork parent history, run parallel helpers, or retry deterministic runtime/scope failures.
 5. If the task needs external repository context provided by the user, use a targeted read-only checkout when available.
 6. Produce an implementation matrix only when multiple platform areas are affected:
 
     | Area | Current behavior | Target behavior | Files/config | Verification |
     |---|---|---|---|---|
 
-7. Implement only the bounded target behavior with one writer by default.
+7. Implement only the bounded target behavior in the parent.
 8. If runtime behavior changes, update README/docs and add or adjust a decision note when appropriate.
 9. Run every exact command returned in `task.verifyCommands` after the latest mutation. For a normal default plan, review the final diff and mark only its review step done with `piagent_task_progress`.
 10. Let runtime hooks record context, verification, trace, and final-gate state. Use recovery tools only if the runtime reports missing evidence.

package/packages/piagent-core/prompts/review.md

@@ -14,13 +14,8 @@ Rules:
 1. Read the current diff and the narrow surrounding source/tests. Runtime hooks inject bounded navigation context when useful.
 2. Select review lenses from the actual change risk; do not load orchestration or diagnostic tools just to choose them.
 3. Stay read-only unless explicitly asked to write a report.
-4. Check protected paths, scope drift, acceptance behavior, and verify-command coverage.
-5. For a non-trivial diff, use bounded read-only reviewers only when independent lanes justify their token cost:
-   - correctness/edge cases;
-   - tests/verification;
-   - scope drift/protected paths;
-   - security/high-risk only when relevant.
-   If the user asks for a loop, use `/review-loop` semantics or equivalent parent-controlled max-round loop. Continue single-agent for tiny diffs or unavailable subagent tooling.
+4. Check protected paths, unrelated change drift, acceptance behavior, and verify-command coverage. Treat task scope as an initial focus, not write authority.
+5. Review directly in the parent. A non-trivial diff does not itself justify another model run. At most one fresh read-only reviewer is eligible only when a runtime estimate proves an independent lane and at least 30% projected total token savings after handoff/merge; never run parallel review or retry a deterministic helper failure. If the user explicitly asks for a loop, keep it parent-controlled and bounded.
 6. Report findings by severity.
 7. Do not call diagnostic Piagent tools for routine review and do not paste full diff/test/tool logs. Summarize the signal and quote only relevant lines.
 

package/packages/piagent-core/prompts/scout.md

@@ -15,7 +15,7 @@ Lean scouting flow:
 
 1. Read targeted current files and return cited evidence. Runtime hooks inject bounded navigation context when useful and enforce read boundaries.
 2. Create a read-only contract with `piagent_task_start` only for a broad governed scout that needs persisted scope or handoff. Tiny default scouts complete from observed reads; for a normal default scout, review the evidence and mark only the returned review step done with `piagent_task_progress`.
-3. Use memory, vendor documentation, or a read-only subagent only when current source is insufficient or the work has independent lanes. Verify advisory material against current files.
+3. Use memory or vendor documentation only when current source is insufficient. Keep scouting in the parent; a helper requires separate runtime proof of two independent lanes and at least 30% projected net token saving.
 4. A low-confidence search may trigger one bounded finder pass. Stop broad search when the requested evidence is covered.
 5. Do not call diagnostic Piagent tools for a routine scout. Load them only when the runtime reports a recovery need or the operator explicitly asks for diagnostics.
 6. Do not edit source or paste full command output. Summarize relevant evidence and unknowns.

package/packages/piagent-core/prompts/task.md

@@ -11,9 +11,9 @@ $ARGUMENTS
 
 Core flow:
 
-1. Use the runtime-created contract for a bounded source task; do not call task-management tools during automatic intake. If runtime pauses for broad, high-risk, or ambiguous scope, call `piagent_task_start` exactly once with project-relative path/glob scope and reuse an active contract.
+1. Use the runtime-created contract for a bounded source task; do not call task-management tools during automatic intake. If runtime pauses for a broad, high-risk, or ambiguous task, call `piagent_task_start` exactly once with project-relative focus paths/globs and reuse an active contract.
 2. Read the likely target and nearest relevant test. The runtime injects bounded navigation context when useful.
-3. Make the smallest in-scope change with ordinary tools and one writer.
+3. Make the smallest complete evidence-backed change with ordinary tools and one writer. Initial task scope guides retrieval/review but does not restrict necessary FE, BE, test, config, or child-repository edits.
 4. Run every exact command returned in `task.verifyCommands` after the latest mutation.
 5. Automatic tasks need no lifecycle calls. Manual high-risk and explicitly requested custom plans keep their returned checkpoints.
 6. Let runtime hooks record context, changed files, verification, trace, and final-gate state. Load recovery tools only if the runtime reports missing evidence.
@@ -21,13 +21,14 @@ Core flow:
 Risk-adaptive enrichment:
 
 - `tiny`: stay targeted; no diagnostic Piagent tools or subagents.
-- `normal`: stop searching once current-file evidence is sufficient. Use a read-only subagent only for a genuinely independent lane.
+- `normal`: stop searching once current-file evidence is sufficient. Keep the parent direct. One fresh read-only helper is eligible only when runtime evidence proves at least two independent lanes and at least 30% projected total token savings after handoff/merge.
 - `high-risk`: inspect current source, relevant vendor documentation, and explicit security/data/release review lenses; keep required human confirmations.
 
 Always:
 
 - Treat memory, context-index, and generated tech snapshots as advisory; verify against current files.
 - If navigation confidence is low, run at most one bounded read-only finder pass; do not start an open-ended scout loop.
+- Never delegate implementation, fork/inherit the parent transcript, run more than one helper, or retry a deterministic helper/runtime/scope failure.
 - Do not touch protected paths or use undeclared capabilities.
 - If verification cannot run, report `blocked` or `partial`, never done. If runtime schedules a continuation, keep working in the same task and do not repeat management tools.
 - Do not paste full test/build/tool logs. Summarize the signal and quote only relevant failures.

package/packages/piagent-core/runtime/context/adaptive-planner.ts

@@ -13,7 +13,7 @@ type ContextUsage = {
 
 export type AdaptiveContextPlan = {
   schemaVersion: 1;
-  phase: "utility" | "protected" | "intake" | "scout" | "execute" | "review" | "release";
+  phase: "utility" | "protected" | "intake" | "scout" | "discuss" | "plan" | "execute" | "review" | "release";
   lane: "tiny" | "normal" | "high-risk";
   shouldInject: boolean;
   budgetTokens: number;
@@ -64,6 +64,8 @@ function phaseFor(signal: ReturnType<typeof classifyContextTask>, input: Planner
   if (signal.workflow === "usage") return "utility";
   if (signal.workflow === "review") return "review";
   if (signal.workflow === "scout" || signal.workflow === "onboard") return "scout";
+  if (signal.workflow === "discuss") return "discuss";
+  if (signal.workflow === "plan") return "plan";
   if (signal.workflow === "release") return "release";
   if (input.runtimeIntake) return "intake";
   return "execute";
@@ -74,6 +76,8 @@ function baseBudget(phase: AdaptiveContextPlan["phase"], lane: AdaptiveContextPl
   if (phase === "review") return lane === "high-risk" ? 720 : 520;
   if (phase === "release") return 620;
   if (phase === "scout") return lane === "high-risk" ? 820 : 640;
+  if (phase === "plan") return lane === "high-risk" ? 680 : 520;
+  if (phase === "discuss") return lane === "high-risk" ? 480 : 360;
   if (phase === "intake") {
     if (explicitPaths > 0) return lane === "high-risk" ? 560 : 420;
     return lane === "high-risk" ? 780 : lane === "tiny" ? 360 : 540;
@@ -130,13 +134,13 @@ export function planAdaptiveContext(input: PlannerInput): AdaptiveContextPlan {
   const limit = explicitPathCount > 0
     ? 4
     : lane === "high-risk" ? 8 : lane === "tiny" ? 4 : 6;
-  const includeCode = phase === "intake" || phase === "review" || explicitPathCount > 0;
+  const includeCode = phase === "intake" || phase === "plan" || phase === "review" || explicitPathCount > 0;
   const includePatterns = phase === "intake" ? DEFAULT_INTAKE_PATTERNS : undefined;
   const reranker = "off" as const;
   if (process.env.PIAGENT_LOCAL_RERANKER === "on") reasons.push("local-reranker:unavailable");
   const minConfidence = explicitPathCount > 0 || lane === "tiny"
     ? "medium"
-    : phase === "review" || phase === "release" || lane === "high-risk"
+    : phase === "plan" || phase === "review" || phase === "release" || lane === "high-risk"
       ? "high"
       : "medium";
   return {

package/packages/piagent-core/runtime/hooks/agent-start-hook.ts

@@ -1,92 +1,67 @@
 import crypto from "node:crypto";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 import {
   buildContextPack,
   classifyContextTask,
   ensureContextIndexV2,
-  estimateContextTokens
+  estimateContextTokens,
+  shouldIndexPath
 } from "../../extensions/context-engine.js";
 import {
   buildSelectedContextPack,
   composeCriterionContextEntries
 } from "../../extensions/criterion-context-pack.js";
 import { matchesProtectedPath } from "../../extensions/policy-core.js";
+import { hasDurableContextEvidence } from "../../extensions/context-evidence.js";
 import { selectRepositoryMemoryFacts } from "../../extensions/repository-memory.js";
-import type { TaskContract } from "../../extensions/guard-types.js";
 import {
   contextPlanAcceptsConfidence,
   planAdaptiveContext
 } from "../context/adaptive-planner.ts";
 import { stageContextDelivery } from "../context/context-delivery.ts";
-import { measureContextDeltaShadow, type ContextDeltaShadowMode } from "../context/context-delta-shadow.ts";
+import { measureContextDeltaShadow } from "../context/context-delta-shadow.ts";
 import { buildPrefixTelemetry } from "../context/prefix-telemetry.ts";
 import { formatRepositoryMemoryHints } from "../context/repository-memory-hints.ts";
 import { modelCapabilityFromContext } from "../model/capabilities.ts";
-import type { RuntimeModelSnapshot } from "../model/runtime-snapshot.ts";
 import type { ModelRouteEvaluation } from "../model/model-route-runtime.ts";
+import type { RuntimeModelSnapshot } from "../model/runtime-snapshot.ts";
 import { buildTaskResumeContext } from "../recovery/resume-state.ts";
 import { planRetrievalRoute } from "../context/retrieval-route-policy.ts";
-import type { SolverShadowEvaluation } from "../solver/solver-shadow.ts";
 import { observeTrajectorySync } from "../trajectory/trajectory-observability.ts";
-import type { TrajectorySyncOptions, TrajectorySyncResult } from "../trajectory/trajectory-runtime.ts";
+import type { SolverShadowEvaluation } from "../solver/solver-shadow.ts";
 import { trajectoryRecommendationRef } from "../trajectory/trajectory-runtime.ts";
-import { RuntimeSessionState, type ContextInjectionItem } from "../session/runtime-state.ts";
+import type { ContextInjectionItem } from "../session/runtime-state.ts";
+import { isUncertainSendContinuation } from "../session/uncertain-send-continuation.ts";
 import {
   compactManagedProjectInstructions,
   rewriteLegacyProjectInstructions
 } from "../session/system-prompt.ts";
 import { PIAGENT_TOOL_NAMES } from "../tools/tool-groups.ts";
-import { extractTaskRequest, looksLikeGovernedBoilerplate } from "../workflows/input-routing.ts";
+import { agentStartTaskRequest } from "../workflows/input-routing.ts";
 import {
   AUTO_INTAKE_SNAPSHOT_PATTERNS,
-  automaticTaskIntakeMode
+  automaticTaskIntakeMode,
+  isLightweightNonAuthorizingChangeContinuation,
+  isNonAuthorizingChangeClarification
 } from "../workflows/task-intake.ts";
 import { CONTEXT_PACK_MAX_TOKENS } from "../runtime-limits.ts";
 import { modelRouteTelemetry, runtimeSnapshotTelemetry, solverShadowTelemetry } from "./agent-prompt-telemetry.ts";
-
-type RuntimeIntakeResult = {
-  started: boolean;
-  text: string;
-  task?: TaskContract;
-  plannedContext?: Array<{ path: string; reason: string }>;
-  plannedContextComplete?: boolean;
-};
-
-type AgentStartHookDependencies = {
-  state: RuntimeSessionState;
-  autoContextEnabled: boolean;
-  contextDeltaShadowMode: ContextDeltaShadowMode;
-  activeTask: (ctx: ExtensionContext) => TaskContract | undefined;
-  readProtectedPaths: (ctx: ExtensionContext) => string[];
-  contextExcludePatterns: (ctx: ExtensionContext) => string[];
-  promptPackKey: (ctx: ExtensionContext, promptHash: string) => string;
-  retrievalKey: (ctx: ExtensionContext, query: string) => string;
-  startAutomaticTask: (query: string, ctx: ExtensionContext) => Promise<RuntimeIntakeResult | undefined>;
-  runtimeSnapshot?: (ctx: ExtensionContext) => RuntimeModelSnapshot | undefined;
-  persistRuntimeSnapshot?: (ctx: ExtensionContext, snapshot: RuntimeModelSnapshot) => unknown;
-  shadowSolver?: (input: {
-    request: string;
-    ctx: ExtensionContext;
-    activeTask?: TaskContract;
-    runtimeSnapshot?: RuntimeModelSnapshot;
-    protectedTarget: boolean;
-  }) => SolverShadowEvaluation;
-  modelRoute?: (input: {
-    ctx: ExtensionContext;
-    features: NonNullable<Extract<SolverShadowEvaluation, { status: "ok" }>["features"]>;
-    runtimeSnapshot?: RuntimeModelSnapshot;
-  }) => Promise<ModelRouteEvaluation>;
-  syncTrajectory?: (ctx: ExtensionContext, task: TaskContract, options: TrajectorySyncOptions) => TrajectorySyncResult;
-  telemetry: (ctx: ExtensionContext, payload: Record<string, unknown>) => void;
-};
+import type { AgentStartHookDependencies } from "./agent-start-types.ts";
 
 export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStartHookDependencies): void {
   pi.on("before_agent_start", async (event, ctx) => {
     const projectInstructions = rewriteLegacyProjectInstructions(event.systemPrompt);
-    const query = looksLikeGovernedBoilerplate(event.prompt) ? extractTaskRequest(event.prompt) : event.prompt.trim();
+    const query = agentStartTaskRequest(event.prompt);
     const signal = classifyContextTask(query);
-    const turn = dependencies.state.currentTurn(ctx, signal.promptHash) ?? dependencies.state.beginTurn(ctx, signal.promptHash);
+    const uncertainSendContinuation = isUncertainSendContinuation(query);
+    // A mutation clarification still goes to the provider unchanged and never
+    // creates a task. Only a lightweight decision also skips repository retrieval.
+    const nonAuthorizingClarification = isNonAuthorizingChangeClarification(query);
+    const lightweightChangeContinuation = isLightweightNonAuthorizingChangeContinuation(query);
+    const turn = dependencies.state.classifyTurn(ctx, signal.promptHash, {
+      lightweightNonAuthorizingChange: lightweightChangeContinuation
+    });
     const readProtectedPaths = dependencies.readProtectedPaths(ctx);
     const protectedTarget = signal.paths.some((candidate) => matchesProtectedPath(candidate, readProtectedPaths));
     const protectedOnlyTarget = signal.paths.length > 0
@@ -119,7 +94,9 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
     const prefix = buildPrefixTelemetry(effectiveSystemPrompt, toolMetadata);
     const toolSchemaTokens = estimateContextTokens(prefix.canonicalToolSurface);
     const systemPromptTokens = estimateContextTokens(effectiveSystemPrompt);
-    const autoPackUseful = activeTask?.trace.outcome !== "pending"
+    const autoPackUseful = !lightweightChangeContinuation
+      && !uncertainSendContinuation
+      && activeTask?.trace.outcome !== "pending"
       && (runtimeIntake || signal.paths.length === 0);
     let runtimeSnapshot: RuntimeModelSnapshot | undefined;
     try {
@@ -172,10 +149,12 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
       content: string;
       details: Record<string, unknown>;
     }) => {
-      const resumed = activeTask ? dependencies.state.takeResumeContextState(ctx, activeTask.taskRunId) : undefined;
+      const resumed = activeTask && !lightweightChangeContinuation
+        ? dependencies.state.takeResumeContextState(ctx, activeTask.taskRunId)
+        : undefined;
       const durableResume = activeTask && resumed ? buildTaskResumeContext(activeTask, resumed) : undefined;
       const selectedContext = contextMessage ?? durableResume;
-      const intake = await dependencies.startAutomaticTask(query, ctx);
+      const intake = nonAuthorizingClarification ? undefined : await dependencies.startAutomaticTask(query, ctx);
       if (intake?.task) observeTrajectorySync(ctx, dependencies.syncTrajectory?.(ctx, intake.task, { sourceHook: "agent-start", recommendationRef }), dependencies.telemetry);
       if (!selectedContext && !intake) return systemPromptUpdate;
       const discoveryItems = selectedContext?.customType === "piagent-context-pack-v2" && Array.isArray(selectedContext.details.selectedItems)
@@ -192,14 +171,23 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
       const criterionLimit = Number.isFinite(Number(discoveryPlan?.limit))
         ? Math.max(1, Math.min(6, Math.trunc(Number(discoveryPlan?.limit))))
         : signal.paths.length > 0 ? 3 : 4;
-      const criterionMode = dependencies.autoContextEnabled && intake?.task?.criterionGraph?.mode === "criterion-graph";
-      const criterionEntries = intake?.task?.criterionGraph?.mode === "criterion-graph"
+      const terminalUncertainSend = intake?.continuation === "terminal-uncertain-send";
+      const criterionMode = dependencies.autoContextEnabled
+        && !terminalUncertainSend
+        && intake?.task?.criterionGraph?.mode === "criterion-graph";
+      const contextExcludePatterns = dependencies.contextExcludePatterns(ctx);
+      // Apply the pack's path eligibility before ranking a singleton fallback.
+      // Otherwise an unsupported/protected candidate can displace a usable
+      // planned source and then be discarded by the pack builder.
+      const packEligible = (entry: { path?: unknown }) => typeof entry.path === "string"
+        && shouldIndexPath(entry.path, { excludePatterns: contextExcludePatterns });
+      const criterionEntries = !terminalUncertainSend && intake?.task?.criterionGraph?.mode === "criterion-graph"
         ? composeCriterionContextEntries({
             explicitPaths: signal.paths,
             criteria: intake.task.acceptanceCriteria,
-            plannedEntries: intake.plannedContext ?? [],
+            plannedEntries: (intake.plannedContext ?? []).filter(packEligible),
             plannedSelectionComplete: intake.plannedContextComplete === true,
-            retrievedItems: discoveryItems
+            retrievedItems: discoveryItems.filter(packEligible)
           }, { limit: criterionLimit })
         : [];
       const criterionContext = criterionMode
@@ -207,7 +195,7 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
             budgetTokens: criterionBudget,
             limit: criterionLimit,
             focusText: [query, ...intake.task.acceptanceCriteria].join("\n"),
-            excludePatterns: dependencies.contextExcludePatterns(ctx)
+            excludePatterns: contextExcludePatterns
           })
         : undefined;
       const criterionReasonCode = !dependencies.autoContextEnabled
@@ -227,7 +215,13 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
       });
       const composedContext = criterionContext?.selected.length ? criterionContext : undefined;
       const deliveredSelectedContext = criterionMode ? undefined : selectedContext;
-      const content = [deliveredSelectedContext?.content, intake?.text, composedContext?.text].filter(Boolean).join("\n\n");
+      // An oversized file without evidenced ranges can legitimately produce an
+      // empty pack. Make the existing read-evidence requirement actionable;
+      // planned paths and earlier turns are not evidence of current delivery.
+      const contextReadGuidance = criterionMode && !composedContext && !hasDurableContextEvidence(intake?.task)
+        ? "No file content was delivered in the bounded context pack. Before completion, use the native read tool on a relevant source or test file in the task scope; use offset/limit for a large file. Shell inspection and passing tests do not record this read evidence. Do not reread the whole repository."
+        : undefined;
+      const content = [deliveredSelectedContext?.content, intake?.text, composedContext?.text, contextReadGuidance].filter(Boolean).join("\n\n");
       const deliveryTask = intake?.task ?? activeTask;
       const selectedPackPaths = deliveredSelectedContext?.customType === "piagent-context-pack-v2" && Array.isArray(deliveredSelectedContext.details.paths)
         ? deliveredSelectedContext.details.paths.filter((value): value is string => typeof value === "string")
@@ -303,6 +297,13 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
                   intakeMode: intake.task.intakeMode
                 }
               : undefined,
+            uncertainSendContinuation: terminalUncertainSend
+              ? {
+                  taskId: intake?.task?.taskId ?? null,
+                  taskRunId: intake?.task?.taskRunId ?? null,
+                  replacementTaskStarted: false
+                }
+              : undefined,
             criterionContext: composedContext ? {
               paths: composedContext.selected.map((entry) => entry.path), estimatedTokens: composedContext.estimatedTokens
             } : undefined,
@@ -313,7 +314,7 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
     };
 
     const packKey = dependencies.promptPackKey(ctx, signal.promptHash);
-    if (!autoPackUseful && activeTask?.trace.outcome === "pending" && query.length >= 20 && signal.workflow !== "usage" && dependencies.autoContextEnabled) {
+    if (!lightweightChangeContinuation && !autoPackUseful && activeTask?.trace.outcome === "pending" && query.length >= 20 && signal.workflow !== "usage" && dependencies.autoContextEnabled) {
       await measureContextDeltaShadow({ ctx, query, turnId: turn.turnId, task: activeTask, mode: dependencies.contextDeltaShadowMode, protectedTarget, excludePatterns: dependencies.contextExcludePatterns(ctx), telemetry: dependencies.telemetry });
     }
     if (
@@ -329,7 +330,7 @@ export function registerAgentStartHook(pi: ExtensionAPI, dependencies: AgentStar
     dependencies.state.rememberAutoPackedPrompt(packKey);
     try {
       const excludePatterns = dependencies.contextExcludePatterns(ctx);
-      const ensured = await ensureContextIndexV2(ctx.cwd, {
+      const ensured = await (dependencies.ensureContextIndex ?? ensureContextIndexV2)(ctx.cwd, {
         excludePatterns,
         rebuildMissing: false
       });

package/packages/piagent-core/runtime/hooks/agent-start-types.ts

@@ -0,0 +1,48 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import type { TaskContract } from "../../extensions/guard-types.js";
+import type { ContextDeltaShadowMode } from "../context/context-delta-shadow.ts";
+import type { ModelRouteEvaluation } from "../model/model-route-runtime.ts";
+import type { RuntimeModelSnapshot } from "../model/runtime-snapshot.ts";
+import type { RuntimeSessionState } from "../session/runtime-state.ts";
+import type { SolverShadowEvaluation } from "../solver/solver-shadow.ts";
+import type { TrajectorySyncOptions, TrajectorySyncResult } from "../trajectory/trajectory-runtime.ts";
+import type { ensureContextIndexV2 } from "../../extensions/context-engine.js";
+
+export type RuntimeIntakeResult = {
+  started: boolean;
+  text: string;
+  task?: TaskContract;
+  plannedContext?: Array<{ path: string; reason: string }>;
+  plannedContextComplete?: boolean;
+  continuation?: "terminal-uncertain-send";
+};
+
+export type AgentStartHookDependencies = {
+  state: RuntimeSessionState;
+  autoContextEnabled: boolean;
+  contextDeltaShadowMode: ContextDeltaShadowMode;
+  activeTask: (ctx: ExtensionContext) => TaskContract | undefined;
+  readProtectedPaths: (ctx: ExtensionContext) => string[];
+  contextExcludePatterns: (ctx: ExtensionContext) => string[];
+  ensureContextIndex?: typeof ensureContextIndexV2;
+  promptPackKey: (ctx: ExtensionContext, promptHash: string) => string;
+  retrievalKey: (ctx: ExtensionContext, query: string) => string;
+  startAutomaticTask: (query: string, ctx: ExtensionContext) => Promise<RuntimeIntakeResult | undefined>;
+  runtimeSnapshot?: (ctx: ExtensionContext) => RuntimeModelSnapshot | undefined;
+  persistRuntimeSnapshot?: (ctx: ExtensionContext, snapshot: RuntimeModelSnapshot) => unknown;
+  shadowSolver?: (input: {
+    request: string;
+    ctx: ExtensionContext;
+    activeTask?: TaskContract;
+    runtimeSnapshot?: RuntimeModelSnapshot;
+    protectedTarget: boolean;
+  }) => SolverShadowEvaluation;
+  modelRoute?: (input: {
+    ctx: ExtensionContext;
+    features: NonNullable<Extract<SolverShadowEvaluation, { status: "ok" }>["features"]>;
+    runtimeSnapshot?: RuntimeModelSnapshot;
+  }) => Promise<ModelRouteEvaluation>;
+  syncTrajectory?: (ctx: ExtensionContext, task: TaskContract, options: TrajectorySyncOptions) => TrajectorySyncResult;
+  telemetry: (ctx: ExtensionContext, payload: Record<string, unknown>) => void;
+};