@zq-silk/yui 2.22.0 → 2.25.0

package/dist/repository/gitWorktreeInventory.js

@@ -1,16 +1,12 @@
-import { execFile } from "node:child_process";
 import { lstat, readFile, readdir, realpath } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
-import { promisify } from "node:util";
 import { gitOutputLine, supportedGit } from "./gitCompatibility.js";
-const execute = promisify(execFile);
-async function run(args) {
-    return (await execute(supportedGit().path, args, {
-        encoding: "utf8", timeout: 10_000, maxBuffer: 1024 * 1024
-    })).stdout;
+import { executeGitCommand } from "./gitCommand.js";
+async function run(args, budget) {
+    return (await executeGitCommand(supportedGit(budget?.totalMs).path, args, { budget })).stdout.toString("utf8");
 }
-export async function gitPath(cwd, args) {
-    return resolve(cwd, gitOutputLine(await run(["-C", cwd, "rev-parse", ...args])));
+export async function gitPath(cwd, args, budget) {
+    return resolve(cwd, gitOutputLine(await run(["-C", cwd, "rev-parse", ...args], budget)));
 }
 async function exists(path) {
     try {
@@ -29,13 +25,13 @@ async function exists(path) {
  * never write/prune them, and never infer ownership merely from a directory.
  * Mutating consumers still check the recorded owner and ask Git to remove it.
  */
-export async function readGitWorktrees(cwd) {
-    const common = await realpath(await gitPath(cwd, ["--git-common-dir"]));
+export async function readGitWorktrees(cwd, budget) {
+    const common = await realpath(await gitPath(cwd, ["--git-common-dir"], budget));
     const result = [];
     // This is also Git's own main-worktree listing convention (including bare
     // and separate-git-dir repositories), not a claim of managed ownership.
     const main = basename(common) === ".git" ? dirname(common) : common;
-    result.push(await inspect(common, main, false));
+    result.push(await inspect(common, main, false, budget));
     const directory = join(common, "worktrees");
     let entries;
     try {
@@ -59,27 +55,27 @@ export async function readGitWorktrees(cwd) {
         const path = dirname(resolve(admin, pointer));
         const adminCommon = await realpath(resolve(cwd, gitOutputLine(await run([
             "-C", cwd, `--git-dir=${admin}`, "rev-parse", "--git-common-dir"
-        ]))));
+        ], budget))));
         if (adminCommon !== common)
             throw new Error(`Git worktree common directory mismatch: ${admin}; retained.`);
         if (await exists(path)) {
-            const actual = await realpath(await gitPath(path, ["--git-dir"]));
+            const actual = await realpath(await gitPath(path, ["--git-dir"], budget));
             if (actual !== admin)
                 throw new Error(`Git worktree back-pointer mismatch: ${path}; retained.`);
         }
-        result.push(await inspect(admin, path, true));
+        result.push(await inspect(admin, path, true, budget));
     }
     if (new Set(result.map(entry => entry.path)).size !== result.length) {
         throw new Error("Duplicate Git worktree registrations; retained.");
     }
     return result;
 }
-async function inspect(admin, path, linked) {
+async function inspect(admin, path, linked, budget) {
     // Ask Git rather than parsing HEAD: Git owns ref storage (including newer
     // backends), symbolic resolution and per-worktree pseudorefs.
     let branch;
     try {
-        branch = gitOutputLine(await run([`--git-dir=${admin}`, "symbolic-ref", "--quiet", "HEAD"]));
+        branch = gitOutputLine(await run([`--git-dir=${admin}`, "symbolic-ref", "--quiet", "HEAD"], budget));
     }
     catch (error) {
         if (error.code !== 1)
@@ -90,7 +86,7 @@ async function inspect(admin, path, linked) {
     }
     let head;
     try {
-        head = gitOutputLine(await run([`--git-dir=${admin}`, "rev-parse", "--verify", "HEAD"]));
+        head = gitOutputLine(await run([`--git-dir=${admin}`, "rev-parse", "--verify", "HEAD"], budget));
         if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/iu.test(head))
             throw new Error("Invalid Git HEAD");
     }
@@ -99,7 +95,7 @@ async function inspect(admin, path, linked) {
         if (branch === undefined)
             throw error;
         try {
-            await run([`--git-dir=${admin}`, "show-ref", "--verify", "--quiet", branch]);
+            await run([`--git-dir=${admin}`, "show-ref", "--verify", "--quiet", branch], budget);
         }
         catch (missing) {
             if (missing.code === 1) {

package/dist/repository/projectRefresh.js

@@ -41,7 +41,7 @@ export async function refreshRegisteredProject(store, id, options = {}) {
     try {
         const current = check();
         options.beforeRefresh?.();
-        const refreshed = await (options.git ?? new NodeGitWorkspace()).refresh({
+        const refreshed = await (options.git ?? new NodeGitWorkspace(() => store.getConfig())).refresh({
             repositoryPath: current.path, remoteUrl: current.remoteUrl, stableRef: current.stableBranch
         });
         return { project: current, ...refreshed };

package/dist/repository/taskBaseFreshness.js

@@ -59,7 +59,7 @@ export function recordTaskBaseProvenanceEvents(tx, taskId, provenance, now) {
 }
 export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
     const task = requireTask(store, taskId);
-    const git = options.git ?? newGitWorkspace();
+    const git = options.git ?? new NodeGitWorkspace(() => store.getConfig());
     const workspace = store.getTaskWorkspace(taskId);
     // Collect active AgentRun workspace snapshots once so every Project entry can
     // report whether a live AgentRun is pinned to a different commit.
@@ -169,9 +169,6 @@ export function renderTaskBaseFreshnessReport(report) {
     }
     return lines.join("\n").concat("\n");
 }
-function newGitWorkspace() {
-    return new NodeGitWorkspace();
-}
 function requireTask(store, taskId) {
     const task = store.getTask(taskId);
     if (task === null)

package/dist/repository/taskWorkspacePreparer.js

@@ -67,7 +67,7 @@ export class FileTaskWorkspacePreparer {
     git;
     now;
     maintenanceLockOptions;
-    constructor(home, store, git = new NodeGitWorkspace(), now = () => new Date(), maintenanceLockOptions = {}) {
+    constructor(home, store, git = new NodeGitWorkspace(() => store.getConfig()), now = () => new Date(), maintenanceLockOptions = {}) {
         this.home = home;
         this.store = store;
         this.git = git;

package/dist/runtime/agentEndpoint.js

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from "node:util";
 import { builtinAgentEndpointImplementation, requireBuiltinAgentEndpointImplementation } from "./agentEndpointIdentity.js";
 import { builtinAgentDriverRegistry } from "./builtinAgentDrivers.js";
 import { CodexPreSubmissionError } from "./codexAppServerRuntime.js";
@@ -80,6 +81,12 @@ function freezeConfiguration(value) {
 class BuiltinAgentEndpoint {
     driver;
     configuration;
+    get contextEpoch() { return this.driver.contextEpoch; }
+    async checkQuiescent() {
+        if (!this.driver.checkQuiescent)
+            throw new Error("This native Endpoint cannot prove background quiescence.");
+        return this.driver.checkQuiescent();
+    }
     get nativeAccess() { return this.driver.nativeAccess; }
     get appliedGeneratedTitle() { return this.driver.appliedGeneratedTitle; }
     get ownedProcessId() { return this.driver.ownedProcessId; }
@@ -147,6 +154,7 @@ class BuiltinAgentEndpoint {
         const previous = this.#attempts.get(input.attemptId);
         if (previous !== undefined) {
             if (previous.input.inputRef !== input.inputRef || previous.input.boundedText !== input.boundedText
+                || !isDeepStrictEqual(previous.input.additionalContext, input.additionalContext)
                 || previous.operation !== operation) {
                 throw new Error("Endpoint attempt identity cannot be reused for different input or operation.");
             }
@@ -160,7 +168,9 @@ class BuiltinAgentEndpoint {
             return { status: "not-submitted", error: new ProviderTurnRejectedError("Endpoint is detached.", input.attemptId) };
         }
         const attempt = {
-            input: Object.freeze({ ...input }),
+            input: Object.freeze({ ...input, ...(input.additionalContext === undefined ? {} : {
+                    additionalContext: structuredClone(input.additionalContext)
+                }) }),
             operation,
             disposition: { status: "pending", reason: "submitting" }
         };

package/dist/runtime/agentEndpointIdentity.js

@@ -35,6 +35,8 @@ const ENDPOINT_CHECKOUT_MODULES = Object.freeze([
     "acpProtocol.js",
     "acpSessionConfiguration.js",
     "agentRunConfiguration.js",
+    "contextRecovery.js",
+    "codexNativeAccess.js",
     "jsonLineChannel.js"
 ]);
 function resolveEndpointGeneration() {