@piagent/platform 1.6.1 → 1.7.1

package/packages/piagent-core/extensions/workspace-revision.js

@@ -0,0 +1,48 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import { gitEvidenceRootDetails } from "./workspace-evidence-roots.js";
+
+export const WORKSPACE_REVISION_VERSION = "workspace-revision-v1";
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+const PREFIX = `${WORKSPACE_REVISION_VERSION}:`;
+export const isWorkspaceRevisionDigest = (value) => typeof value === "string" && /^workspace-revision-v1:[a-f0-9]{64}$/.test(value);
+
+function git(cwd, args) {
+  return execFileSync("git", ["-c", "core.fsmonitor=false", "--no-optional-locks", "-C", cwd, ...args], {
+    encoding: "utf8", timeout: 3000, maxBuffer: 8192, stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+
+export function repositoryHeadIdentity(cwd) {
+  try {
+    const head = git(cwd, ["rev-parse", "--verify", "--quiet", "HEAD"]);
+    if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(head)) throw new Error("Invalid repository revision");
+    return head;
+  } catch (error) {
+    if (error.status !== 1) throw error;
+    const reference = git(cwd, ["symbolic-ref", "--quiet", "HEAD"]);
+    if (!reference.startsWith("refs/heads/")) throw new Error("Invalid unborn repository");
+    try { git(cwd, ["show-ref", "--verify", "--quiet", reference]); }
+    catch (missing) { if (missing.status === 1) return `unborn:${reference}`; throw missing; }
+    throw new Error("Repository revision changed during capture");
+  }
+}
+
+/** Baseline identity, not a content digest or authenticated verifier receipt. */
+export function captureWorkspaceRevision(cwd) {
+  const root = fs.realpathSync.native(cwd);
+  const details = gitEvidenceRootDetails(root);
+  if (!details.complete || details.roots.length === 0 || details.roots.length > 128) throw new Error("Workspace baseline inventory is unavailable");
+  const repositories = details.roots.map((item) => Object.freeze({
+    prefix: item.prefix,
+    rootId: hash(fs.realpathSync.native(git(item.cwd, ["rev-parse", "--show-toplevel"]))),
+    head: repositoryHeadIdentity(item.cwd)
+  }));
+  const binding = Object.freeze({ version: WORKSPACE_REVISION_VERSION, projectId: hash(root), repositories: Object.freeze(repositories) });
+  return Object.freeze({ ...binding, digest: `${PREFIX}${hash(JSON.stringify(binding))}` });
+}
+
+export function currentWorkspaceRevisionDigest(cwd) {
+  try { return captureWorkspaceRevision(cwd).digest; } catch { return null; }
+}

package/packages/piagent-core/extensions/workspace-verification-snapshot.js

@@ -0,0 +1,13 @@
+import { workingTreeSnapshot } from "./task-state.js";
+import { workingTreeObservation } from "./working-tree-digest.js";
+import { currentWorkspaceRevisionDigest } from "./workspace-revision.js";
+
+/** Bracket content capture with baseline checks; neither alone proves current code. */
+export function captureWorkspaceVerificationSnapshot(cwd, options = {}) {
+  const before = currentWorkspaceRevisionDigest(cwd);
+  const observation = workingTreeObservation(workingTreeSnapshot(cwd, options));
+  const after = currentWorkspaceRevisionDigest(cwd);
+  const workspaceRevisionDigest = before !== null && before === after ? before : null;
+  return Object.freeze({ ...observation, workspaceRevisionDigest,
+    proofCapable: observation.proofCapable && workspaceRevisionDigest !== null });
+}

package/packages/piagent-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piagent/core",
-  "version": "1.6.1",
+  "version": "1.7.1",
   "type": "module",
   "private": true,
   "license": "MIT",
@@ -33,8 +33,8 @@
     }
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "0.84.1",
-    "typebox": "1.3.7"
+    "@earendil-works/pi-coding-agent": "0.86.1",
+    "typebox": "1.3.27"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {

package/packages/piagent-core/policies/base-policy.json

@@ -264,6 +264,7 @@
   },
   "finalGate": {
     "defaultMode": "enforce",
+    "acceptanceProofMode": "diagnostic",
     "requireTaskContract": true,
     "requireContextManifest": true,
     "requireVerifyEvidence": true,

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;
+};