opencode-agent-skill 15.0.0 → 15.1.0

package/pi/extensions/ues-child-runtime.ts

@@ -14,6 +14,7 @@ import {
 import {
   applyAnchoredFileEdits,
   diagnoseCode,
+  lspOperation,
   probeCodeIntelligence,
   readAnchoredCode,
   searchCodeIntelligence,
@@ -272,13 +273,20 @@ export default function (pi: ExtensionAPI) {
     name: "ues_code",
     label: "UES Code Intelligence",
     description:
-      "Bounded code/document/context intelligence for weak models: semantic/AST search, hash-anchored reads, optional LSP diagnostics, optional MarkItDown ingestion, and reversible context recovery.",
+      "Bounded code/document/context intelligence for weak models: semantic/AST search, hash-anchored reads, deterministic LSP definition/references/symbols/hover/rename-preview/call hierarchy, diagnostics, optional MarkItDown ingestion, and reversible context recovery.",
     parameters: Type.Object({
       action: Type.Union([
         Type.Literal("status"),
         Type.Literal("search"),
         Type.Literal("read"),
         Type.Literal("diagnostics"),
+        Type.Literal("definition"),
+        Type.Literal("references"),
+        Type.Literal("symbols"),
+        Type.Literal("hover"),
+        Type.Literal("rename-preview"),
+        Type.Literal("incoming-calls"),
+        Type.Literal("outgoing-calls"),
         Type.Literal("document"),
         Type.Literal("context-expand"),
         Type.Literal("context-search"),
@@ -289,6 +297,10 @@ export default function (pi: ExtensionAPI) {
       language: Type.Optional(Type.String()),
       startLine: Type.Optional(Type.Number({ minimum: 1 })),
       endLine: Type.Optional(Type.Number({ minimum: 1 })),
+      line: Type.Optional(Type.Number({ minimum: 1, description: "1-based source line for LSP operations" })),
+      character: Type.Optional(Type.Number({ minimum: 1, description: "1-based source character for LSP operations" })),
+      newName: Type.Optional(Type.String({ minLength: 1, maxLength: 512 })),
+      includeDeclaration: Type.Optional(Type.Boolean()),
       ref: Type.Optional(Type.String()),
       maxBytes: Type.Optional(Type.Number({ minimum: 1, maximum: 128000 })),
     }),
@@ -320,7 +332,18 @@ export default function (pi: ExtensionAPI) {
           };
         } else if (params.action === "diagnostics") {
           if (!params.file) throw new Error("ues_code diagnostics requires file");
-          result = await diagnoseCode(ctx.cwd, params.file, { timeoutMs: 3000, maxDiagnostics: 40 });
+          result = await diagnoseCode(ctx.cwd, params.file, { timeoutMs: 5000, maxResults: 80 });
+        } else if (["definition", "references", "symbols", "hover", "rename-preview", "incoming-calls", "outgoing-calls"].includes(params.action)) {
+          if (!params.file) throw new Error(`ues_code ${params.action} requires file`);
+          if (params.action === "rename-preview" && !params.newName) throw new Error("ues_code rename-preview requires newName");
+          result = await lspOperation(ctx.cwd, params.file, params.action, {
+            line: params.line || 1,
+            character: params.character || 1,
+            newName: params.newName,
+            includeDeclaration: params.includeDeclaration,
+            timeoutMs: 7000,
+            maxResults: 120,
+          });
         } else if (params.action === "document") {
           if (!params.file) throw new Error("ues_code document requires file");
           const document = await ingestDocument(ctx.cwd, params.file, { maxBytes: Math.min(Number(params.maxBytes || 4 * 1024 * 1024), 4 * 1024 * 1024) });

package/pi/extensions/ues.ts

@@ -35,7 +35,9 @@ import { turboFastPathDecision, turboFastTimeoutBudget } from "../../lib/turbo-f
 import { failureDelta, leafTaskPolicy } from "../../lib/leaf-runtime-optimizer.mjs";
 import { planningRuntimeBudget, shouldSoftSteerArchitect, shouldSoftSteerPlanningRole } from "../../lib/planning-speed-policy.mjs";
 import { sourceFacingPaths, sourceGitPathspecs } from "../../lib/runtime-artifacts.mjs";
+import { createSubagentArtifact, failSubagentArtifact, finalizeSubagentArtifact, listSubagentArtifacts, readSubagentArtifact } from "../../lib/subagent-artifacts.mjs";
 import { buildExecutionContract, buildFinalVerdictMatrix, captureInheritedDirtyState, detectInheritedDirtyViolations, enforcePhaseGates, executionContractPrompt, phaseArtifactPayloads, taskExplicitlyAllowsLocalEnvWrite } from "../../lib/execution-contract.mjs";
+import { buildCompactionResumeGuard, checkpointDurableWorkBeforeCompaction, renderCompactionResumeGuard } from "../../lib/compaction-resume-guard.mjs";
 import { sessionNameFromUesInput, uesSessionName } from "../../lib/session-display.mjs";
 import { requireGitWorkspaceRoot, resolveGitWorkspaceRoot } from "../../lib/workspace-root.mjs";
 import { createAdaptiveDeadline } from "../../lib/activity-deadline.mjs";
@@ -43,7 +45,8 @@ import { extractValidatedPlan } from "../../lib/plan-salvage.mjs";
 import { auditCompletion } from "../../lib/completion-auditor.mjs";
 import { mcpExecutionPolicy } from "../../lib/mcp-tool-policy.mjs";
 import { McpHealthTracker } from "../../lib/mcp-health.mjs";
-import { runtimeWorkspaceFingerprint, runtimeWorkspaceSnapshot } from "../../lib/workspace-fingerprint.mjs";
+import { captureWorkspaceStateV2, runtimeWorkspaceFingerprint, runtimeWorkspaceSnapshot } from "../../lib/workspace-fingerprint.mjs";
+import { captureWorkspaceHygieneBaseline, postRunFileHygiene, preFinalWorkspaceAudit } from "../../lib/workspace-hygiene.mjs";
 import { appendTrajectoryEvent, createTraceID } from "../../lib/trajectory.mjs";
 import {
   browserEvidenceNeeded,
@@ -272,6 +275,7 @@ type RunResult = {
   browserTools?: string[];
   childRuntime?: "rpc" | "cli";
   workerReused?: boolean;
+  subagentArtifact?: any;
   optimizations?: any;
 };
 
@@ -1510,8 +1514,24 @@ async function runRoutedAgent(
   taskPolicyOverride?: any,
   contextCacheNamespace?: string,
 ): Promise<RunResult> {
+  const routedStartedAt = Date.now();
   const role = roleForAgent(agent);
   const traceRoot = requireGitWorkspaceRoot(cwd, "UES specialist");
+  const workspaceSnapshotStartedAt = Date.now();
+  let agentWorkspaceState: any = null;
+  let workspaceState: any = {
+    cacheable: false,
+    fingerprint: "unknown",
+    changedFiles: [],
+  };
+  try {
+    agentWorkspaceState = captureWorkspaceStateV2(cwd);
+    workspaceState = runtimeWorkspaceSnapshot(cwd, { workspaceState: agentWorkspaceState });
+  } catch {}
+  const agentHygieneBaseline = captureWorkspaceHygieneBaseline(cwd, {
+    workspaceState: agentWorkspaceState,
+  });
+  const workspaceSnapshotMs = Date.now() - workspaceSnapshotStartedAt;
   const browserRequested = browserEvidenceNeeded(task, role);
   const browserTools = browserRequested
     ? selectBrowserToolsForTask(HOST_BROWSER_TOOL_NAMES, task, role)
@@ -1573,14 +1593,6 @@ async function runRoutedAgent(
     ? undefined
     : inheritedThinking;
 
-  let workspaceState: any = {
-    cacheable: false,
-    fingerprint: "unknown",
-    changedFiles: [],
-  };
-  try {
-    workspaceState = runtimeWorkspaceSnapshot(cwd);
-  } catch {}
   const workspaceFingerprint = String(workspaceState.fingerprint || "unknown");
 
   let enrichedTask = task;
@@ -1590,6 +1602,8 @@ async function runRoutedAgent(
   let affectedTests: any = null;
   let reusableVerification: any = null;
   let contextCacheHit = false;
+  let contextPerformance: any = null;
+  const contextBuildStartedAt = Date.now();
   try {
     if (fastBoundedContext) {
       contextQuality = { schemaVersion: 1, profile: "fast-bounded", bounded: true };
@@ -1685,6 +1699,7 @@ async function runRoutedAgent(
     }
 
     contextQuality = pack.contextQuality;
+    contextPerformance = pack.performance || null;
     enrichedTask = [
       task,
       "",
@@ -1723,6 +1738,7 @@ async function runRoutedAgent(
       enrichedTask += "\n\n## Previous failed verification\n" + cap(recentFailure, 5000);
     }
   }
+  const contextBuildMs = Date.now() - contextBuildStartedAt;
 
   if (browserRequested) {
     enrichedTask += browserTools.length
@@ -1747,7 +1763,34 @@ async function runRoutedAgent(
     taskChars: task.length,
   });
   const startedAt = Date.now();
-  const result = await runAgent(
+  const artifactRoot = await taskSandboxOwnerRoot(cwd).catch(() => null) || traceRoot;
+  const childArtifact = await createSubagentArtifact(artifactRoot, {
+    agent,
+    role,
+    attempt,
+    task,
+    traceID,
+    model: selectedModel,
+    modelTier: selection.tier,
+    workspaceFingerprint,
+  }).catch(() => null);
+  if (childArtifact?.handle) {
+    try {
+      onProgress?.({
+        agent,
+        elapsedMs: 0,
+        idleMs: 0,
+        toolCalls: 0,
+        model: selectedModel,
+        phase: "running",
+        note: `subagent handle ${childArtifact.handle}; durable status ${childArtifact.file}`,
+      });
+    } catch {}
+  }
+  let result: RunResult;
+  const modelRunStartedAt = Date.now();
+  try {
+    result = await runAgent(
     agent,
     enrichedTask,
     cwd,
@@ -1801,8 +1844,56 @@ async function runRoutedAgent(
       allowLocalEnvWrite:
         taskPolicy.localEnvWriteExplicitlyAllowed === true ||
         taskExplicitlyAllowsLocalEnvWrite(task),
-    },
-  );
+      },
+    );
+  } catch (error) {
+    if (childArtifact?.handle) {
+      await failSubagentArtifact(artifactRoot, childArtifact.handle, error).catch(() => null);
+    }
+    throw error;
+  }
+  const modelRunMs = Date.now() - modelRunStartedAt;
+  const hygieneStartedAt = Date.now();
+  const postRunHygiene = await postRunFileHygiene(cwd, {
+    baseline: agentHygieneBaseline,
+    taskText: task,
+    allowSourceMutations: WRITE_AGENTS.has(agent),
+    autoClean: true,
+  }).catch((error) => ({
+    schemaVersion: 1,
+    safe: false,
+    changed: [],
+    created: [],
+    removed: [],
+    findings: [{
+      kind: "hygiene-audit-error",
+      file: ".",
+      message: error instanceof Error ? error.message : String(error),
+    }],
+    summary: "workspace hygiene audit failed: " + (error instanceof Error ? error.message : String(error)),
+  }));
+  if (!postRunHygiene.safe) {
+    const hygieneText = [
+      "UES post-run workspace hygiene guard rejected this child run.",
+      postRunHygiene.summary || "workspace hygiene failed",
+    ].join("\n");
+    result = {
+      ...result,
+      exitCode: result.exitCode === 0 ? 2 : result.exitCode,
+      stopReason: "error",
+      errorMessage: hygieneText,
+      output: [result.output, "", hygieneText].filter(Boolean).join("\n"),
+    };
+  }
+
+  const hygieneMs = Date.now() - hygieneStartedAt;
+    const finalizedChildArtifact = childArtifact?.handle
+    ? await finalizeSubagentArtifact(artifactRoot, childArtifact.handle, {
+        ...result,
+        durationMs: Date.now() - startedAt,
+        verdict: verdictFromOutput(result.output),
+      }).catch(() => null)
+    : null;
   const enrichedResult: RunResult = {
     ...result,
     task,
@@ -1833,10 +1924,32 @@ async function runRoutedAgent(
       turboFastStrategy: turboFast.strategy,
       turboFastTimeouts: turboFast.eligible ? TURBO_FAST_TIMEOUTS : null,
       planningRuntimeBudget: planningBudget,
+      affectedTestInventorySource: affectedTests?.inventorySource || null,
+      contextPerformance,
+      latencyMs: {
+        workspaceSnapshot: workspaceSnapshotMs,
+        contextBuild: contextBuildMs,
+        modelRun: modelRunMs,
+        hygiene: hygieneMs,
+        total: Date.now() - routedStartedAt,
+      },
     },
     verdict: verdictFromOutput(result.output),
     report: parseStructuredReport(result.output),
     durationMs: Date.now() - startedAt,
+    subagentArtifact: finalizedChildArtifact ? {
+      handle: finalizedChildArtifact.handle,
+      status: finalizedChildArtifact.status,
+      file: finalizedChildArtifact.file,
+      taskRef: finalizedChildArtifact.taskRef,
+      outputRef: finalizedChildArtifact.result?.outputRef || null,
+      resume: finalizedChildArtifact.resume || null,
+    } : childArtifact ? {
+      handle: childArtifact.handle,
+      status: childArtifact.status,
+      file: childArtifact.file,
+      taskRef: childArtifact.taskRef,
+    } : null,
   };
   if (traceID) {
     await appendTrajectoryEvent(traceRoot, traceID, "agent.completed", {
@@ -2848,6 +2961,40 @@ export default function (pi: ExtensionAPI) {
     deactivateParentUesTools();
   });
 
+  pi.on("session_before_compact", async (event, ctx) => {
+    const root = resolveGitWorkspaceRoot(ctx.cwd || "");
+    if (!root) return undefined;
+    await checkpointDurableWorkBeforeCompaction(root, {
+      reason: event.reason,
+      maxWorkspaces: 3,
+    }).catch(() => []);
+    return undefined;
+  });
+
+  pi.on("session_compact", async (event, ctx) => {
+    const root = resolveGitWorkspaceRoot(ctx.cwd || "");
+    if (!root) return;
+    const packet = await buildCompactionResumeGuard(root, {
+      reason: event.reason,
+      maxWorkspaces: 3,
+    }).catch(() => null);
+    if (!packet?.workspaces?.length) return;
+    const content = renderCompactionResumeGuard(packet);
+    if (!content) return;
+    pi.sendMessage({
+      customType: "ues-durable-resume-guard",
+      content,
+      display: false,
+      details: {
+        schemaVersion: 1,
+        reason: event.reason,
+        willRetry: event.willRetry,
+        workspaceCount: packet.workspaceCount,
+        source: packet.source,
+      },
+    }, { triggerTurn: false });
+  });
+
   pi.on("session_shutdown", async () => {
     directControllerAbort?.abort();
     directControllerAbort = null;
@@ -3212,7 +3359,13 @@ export default function (pi: ExtensionAPI) {
       const cwd = requireGitWorkspaceRoot(params.cwd || ctx.cwd, "ues_execute");
       const inheritedModel = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
       const inheritedThinking = ctx.thinkingLevel as string | undefined;
-      const inheritedDirty = captureInheritedDirtyState(cwd);
+      const controllerWorkspaceState = captureWorkspaceStateV2(cwd);
+      const inheritedDirty = captureInheritedDirtyState(cwd, {
+        workspaceState: controllerWorkspaceState,
+      });
+      const controllerHygieneBaseline = captureWorkspaceHygieneBaseline(cwd, {
+        workspaceState: controllerWorkspaceState,
+      });
       const executionContract = buildExecutionContract(params.task, inheritedDirty);
       const contractPrompt = executionContractPrompt(executionContract);
       const suppliedPolicy = (params as any).__taskPolicy;
@@ -4043,6 +4196,56 @@ export default function (pi: ExtensionAPI) {
             };
           }
 
+          const finalWriteScope = [...new Set(
+            structuredPlan.tasks.flatMap((task: any) => taskWriteFiles(task)),
+          )];
+          const preFinalAudit = await preFinalWorkspaceAudit(cwd, {
+            baseline: controllerHygieneBaseline,
+            taskText: params.task,
+            allowedPaths: finalWriteScope,
+            strictScope: true,
+            allowSourceMutations: true,
+          }).catch((error) => ({
+            safe: false,
+            summary: "pre-final workspace audit failed: " + (error instanceof Error ? error.message : String(error)),
+            findings: [],
+          }));
+          if (!preFinalAudit.safe) {
+            if (durableWork) {
+              await durableRecordIntegration(
+                cwd,
+                durableWork.slug,
+                "PARTIAL",
+                preFinalAudit.summary || "pre-final workspace hygiene failed",
+                signal,
+              ).catch(() => {});
+            }
+            return {
+              content: [{
+                type: "text",
+                text: [
+                  "UES pre-final workspace audit blocked PASS.",
+                  "The final repository contains an undeclared, transient, or Unicode-unsafe change.",
+                  "",
+                  preFinalAudit.summary || "workspace hygiene failed",
+                ].join("\n"),
+              }],
+              details: {
+                mode: "execute",
+                policy,
+                steps,
+                structuredPlan,
+                scheduled,
+                durableWork,
+                verdictMatrix,
+                executionContract,
+                preFinalAudit,
+                traceID,
+              },
+              isError: true,
+            };
+          }
+
           let durableFinalization: any = null;
           if (durableWork) {
             const finalEvidence = finalEvidenceForContract;
@@ -4381,6 +4584,37 @@ export default function (pi: ExtensionAPI) {
           };
         }
 
+        const preFinalAudit = await preFinalWorkspaceAudit(cwd, {
+          baseline: controllerHygieneBaseline,
+          taskText: params.task,
+          strictScope: false,
+          allowSourceMutations: true,
+        }).catch((error) => ({
+          safe: false,
+          summary: "pre-final workspace audit failed: " + (error instanceof Error ? error.message : String(error)),
+          findings: [],
+        }));
+        if (!preFinalAudit.safe) {
+          recentFailure = "Pre-final workspace audit rejected PASS: " + (preFinalAudit.summary || "workspace hygiene failed");
+          await recordRuntimeOutcome(implementation, params.task, false, attempt - 1);
+          if (attempt < maxAttempts) continue;
+          return {
+            content: [{ type: "text", text: recentFailure }],
+            details: {
+              mode: "execute",
+              policy,
+              steps,
+              attempts: attempt,
+              completionAudit,
+              verdictMatrix,
+              executionContract,
+              preFinalAudit,
+              traceID,
+            },
+            isError: true,
+          };
+        }
+
         await recordRuntimeOutcome(implementation, params.task, true, attempt - 1);
         const memory = await rememberVerifiedTask(cwd, params.task, verification, integrationResult);
         const final = steps.at(-1);
@@ -4425,6 +4659,10 @@ export default function (pi: ExtensionAPI) {
         "Package root: " + PACKAGE_ROOT,
         "Child runtime: " + CHILD_RUNTIME,
         "Adaptive context: " + (ADAPTIVE_CONTEXT_ENABLED ? "on" : "off"),
+        "Unified workspace snapshot V2: on",
+        "Parallel context preparation: on",
+        "Git-index affected-test inventory: on",
+        "Parallel verification evidence I/O: on",
         "Micro skills: " + (MICRO_SKILLS_ENABLED ? "on" : "off"),
         "Turbo Fast Path: on",
         "Parent UES tools hidden outside UES runs: on",
@@ -4435,6 +4673,9 @@ export default function (pi: ExtensionAPI) {
         "Portable temp-path guard: on",
         "Explicit phase barriers: on",
         "Independent final verdict matrix: on",
+        "Unicode source hygiene: blocking bidi/zero-width/control/homoglyph audit",
+        "Post-run file hygiene: transient cleanup + read-only mutation guard",
+        "Pre-final workspace audit: on",
         "Disk hygiene: bounded + auto-clean",
         "Writer concurrency: " + MAX_WRITER_CONCURRENCY,
       ].join("\n");
@@ -4766,9 +5007,11 @@ export default function (pi: ExtensionAPI) {
     name: "ues_dispatch",
     label: "UES Dispatch",
     description:
-      "Run bundled UES specialist agents in isolated child Pi processes. Supports single, parallel, or chain mode. Parallel writer agents fail closed unless each writer has an explicit distinct cwd/worktree. Available agents: " +
+      "Run bundled UES specialist agents in isolated child Pi processes, or inspect durable child handles with action=status/list. Every child run writes a small artifact with exact task/output evidence references. Supports single, parallel, or chain mode. Parallel writer agents fail closed unless each writer has an explicit distinct cwd/worktree. Available agents: " +
       Object.keys(AGENTS).join(", "),
     parameters: Type.Object({
+      action: Type.Optional(Type.Union([Type.Literal("run"), Type.Literal("status"), Type.Literal("list")])),
+      handle: Type.Optional(Type.String({ description: "Subagent artifact handle for status action" })),
       agent: Type.Optional(Type.String({ description: "Agent name for single mode" })),
       task: Type.Optional(Type.String({ description: "Task for single mode" })),
       cwd: Type.Optional(Type.String({ description: "Working directory for single mode" })),
@@ -4777,6 +5020,39 @@ export default function (pi: ExtensionAPI) {
     }),
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       refreshHostBrowserToolNames(pi);
+      const action = String(params.action || "run");
+      const baseCwd = ctx.cwd;
+      if (action === "status") {
+        if (!params.handle) {
+          return {
+            content: [{ type: "text", text: "ues_dispatch action=status requires handle." }],
+            details: { mode: "status" },
+            isError: true,
+          };
+        }
+        try {
+          const root = requireGitWorkspaceRoot(baseCwd, "ues_dispatch status");
+          const artifact = await readSubagentArtifact(root, params.handle);
+          return {
+            content: [{ type: "text", text: JSON.stringify(artifact, null, 2) }],
+            details: { mode: "status", artifact },
+          };
+        } catch (error) {
+          return {
+            content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+            details: { mode: "status", handle: params.handle },
+            isError: true,
+          };
+        }
+      }
+      if (action === "list") {
+        const root = requireGitWorkspaceRoot(baseCwd, "ues_dispatch list");
+        const artifacts = await listSubagentArtifacts(root, { limit: 20 });
+        return {
+          content: [{ type: "text", text: JSON.stringify(artifacts, null, 2) }],
+          details: { mode: "list", artifacts },
+        };
+      }
       const hasSingle = Boolean(params.agent && params.task);
       const hasParallel = Boolean(params.tasks?.length);
       const hasChain = Boolean(params.chain?.length);
@@ -4791,7 +5067,6 @@ export default function (pi: ExtensionAPI) {
       const validateAgent = (name: string): name is AgentName => name in AGENTS;
       const model = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
       const thinking = ctx.thinkingLevel as string | undefined;
-      const baseCwd = ctx.cwd;
 
       if (hasSingle) {
         if (!validateAgent(params.agent!)) {