@webpresso/agent-kit 3.3.3 → 3.3.5

package/dist/esm/tool-runtime/resolve-runner.js

@@ -1,12 +1,11 @@
 import { existsSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { createRequire } from "node:module";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { Worker } from "node:worker_threads";
 import { resolveAgentKitPackageRoot } from "#cli/commands/init/package-root.js";
 import { resolveGlobalCapableVpCommand } from "#cli/global-vp.js";
 import { pathCandidates } from "#runtime/command-exists.js";
 import { readTrustedJsonFile } from "#shared-utils/read-json-file.js";
+import { isManagedRtkAvailable, resolveManagedRtkExecutable } from "./managed-rtk.js";
 const require = createRequire(import.meta.url);
 const MANAGED_TOOL_PREFIX = {
     oxfmt: {
@@ -33,196 +32,8 @@ const MANAGED_TOOL_PREFIX = {
     wrangler: { packageName: "wrangler", binName: "wrangler" },
 };
 let rtkAvailable = null;
-// The real token-killer `rtk` exposes a `gain` analytics subcommand (see
-// RTK.md); the unrelated `reachingforthejack/rtk` (Rust Type Kit) collision
-// binary does not. Probe that capability instead of `--version`, which *any*
-// `rtk` on PATH answers with exit 0 — trusting it would route wrapped commands
-// (typecheck/qa/test gates) through a foreign binary that may mangle args or
-// drop the wrapped exit code, masking a failing gate as green.
-const RTK_CAPABILITY_ARGS = ["gain", "--help"];
-// Measured cold cost of `rtk gain --help` is ~11ms; 3s is generous headroom.
-// A probe that exceeds it is a broken or wrong binary, so degrade to unfiltered
-// output rather than let a hung `rtk` stall every wrapped command (per
-// no-timeout-as-fix: the bound surfaces the fault, it does not silence it).
-const RTK_PROBE_TIMEOUT_MS = 3000;
-const RTK_PROBE_ESCALATION_DELAY_MS = 250;
-const RTK_PROBE_FORCE_KILL_OBSERVE_MS = 1000;
-const RTK_PROBE_ADAPTER_SLACK_MS = 1000;
-const RTK_PROBE_ADAPTER_TIMEOUT_MS = RTK_PROBE_TIMEOUT_MS +
-    RTK_PROBE_ESCALATION_DELAY_MS +
-    RTK_PROBE_FORCE_KILL_OBSERVE_MS +
-    RTK_PROBE_ADAPTER_SLACK_MS;
-const RTK_PROBE_STATUS_INDEX = 0;
-const RTK_PROBE_PID_INDEX = 1;
-const RTK_PROBE_PENDING = 0;
-const RTK_PROBE_AVAILABLE = 1;
-const RTK_PROBE_UNAVAILABLE = 2;
-const RTK_PROBE_CLEANUP_FAILED = 3;
-// `resolveRunner` is intentionally synchronous because it is also used by pure
-// command planners. The worker keeps that contract while allowing the inner
-// probe to use the same async, owned-process-group supervisor as long-running
-// command surfaces. The main thread only waits on shared state; it never owns a
-// timeout-killed wrapper whose descendants can escape.
-const RTK_PROBE_WORKER_SOURCE = String.raw `
-(async () => {
-  const [{ spawn }, { workerData }] = await Promise.all([
-    import("node:child_process"),
-    import("node:worker_threads"),
-  ]);
-  const state = new Int32Array(workerData.state);
-  let settled = false;
-  const finish = (status) => {
-    if (settled) return;
-    settled = true;
-    Atomics.store(state, workerData.statusIndex, status);
-    Atomics.notify(state, workerData.statusIndex);
-  };
-
-  try {
-    const {
-      createTerminationAwareChild,
-      terminateOwnedProcessTreeWithEscalation,
-    } = await import(workerData.supervisorModuleUrl);
-    if (
-      typeof createTerminationAwareChild !== "function" ||
-      typeof terminateOwnedProcessTreeWithEscalation !== "function"
-    ) {
-      finish(workerData.cleanupFailed);
-      return;
-    }
-
-    const child = spawn("rtk", workerData.args, {
-      detached: process.platform !== "win32",
-      stdio: "ignore",
-      windowsHide: true,
-    });
-    if (child.pid) Atomics.store(state, workerData.pidIndex, child.pid);
-    const tracked = createTerminationAwareChild(child, {
-      kind: "owned-process-group",
-      detached: true,
-    });
-
-    let resolving = false;
-    let timer;
-    const resolveAfterCleanup = async (status) => {
-      if (resolving) return;
-      resolving = true;
-      if (timer) clearTimeout(timer);
-      await terminateOwnedProcessTreeWithEscalation(tracked, {
-        escalationDelayMs: workerData.escalationDelayMs,
-      });
-      finish(status);
-    };
-    const settle = (status) => {
-      void resolveAfterCleanup(status).catch(() => finish(workerData.cleanupFailed));
-    };
-
-    timer = setTimeout(() => {
-      settle(workerData.unavailable);
-    }, workerData.timeoutMs);
-    child.once("error", () => {
-      settle(workerData.unavailable);
-    });
-    child.once("close", (code) => {
-      settle(code === 0 ? workerData.available : workerData.unavailable);
-    });
-  } catch {
-    finish(workerData.cleanupFailed);
-  }
-})();
-`;
-function probeRtkAvailability() {
-    if (rtkAvailable !== null)
-        return rtkAvailable;
-    const supervisorModuleUrl = resolveProbeSupervisorModuleUrl();
-    if (supervisorModuleUrl === null) {
-        rtkAvailable = false;
-        return rtkAvailable;
-    }
-    const state = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 2));
-    let worker;
-    try {
-        worker = new Worker(RTK_PROBE_WORKER_SOURCE, {
-            eval: true,
-            workerData: {
-                args: RTK_CAPABILITY_ARGS,
-                available: RTK_PROBE_AVAILABLE,
-                unavailable: RTK_PROBE_UNAVAILABLE,
-                cleanupFailed: RTK_PROBE_CLEANUP_FAILED,
-                statusIndex: RTK_PROBE_STATUS_INDEX,
-                pidIndex: RTK_PROBE_PID_INDEX,
-                state: state.buffer,
-                supervisorModuleUrl,
-                timeoutMs: RTK_PROBE_TIMEOUT_MS,
-                escalationDelayMs: RTK_PROBE_ESCALATION_DELAY_MS,
-            },
-        });
-        worker.unref();
-        Atomics.wait(state, RTK_PROBE_STATUS_INDEX, RTK_PROBE_PENDING, RTK_PROBE_ADAPTER_TIMEOUT_MS);
-        const status = Atomics.load(state, RTK_PROBE_STATUS_INDEX);
-        if (status === RTK_PROBE_PENDING || status === RTK_PROBE_CLEANUP_FAILED) {
-            forceReclaimProbe(Atomics.load(state, RTK_PROBE_PID_INDEX));
-        }
-        rtkAvailable = status === RTK_PROBE_AVAILABLE;
-    }
-    catch {
-        rtkAvailable = false;
-    }
-    finally {
-        void worker?.terminate();
-    }
-    return rtkAvailable;
-}
-function resolveProbeSupervisorModuleUrl() {
-    const sourceExtension = import.meta.url.endsWith(".ts") ? "ts" : "js";
-    const adjacent = new URL(`../utils/process-supervisor.${sourceExtension}`, import.meta.url);
-    try {
-        if (adjacent.protocol === "file:" && existsSync(fileURLToPath(adjacent))) {
-            return adjacent.href;
-        }
-    }
-    catch {
-        // Native runtimes can expose a virtual import.meta.url; fall back to the package root.
-    }
-    const packageRoot = resolveAgentKitPackageRoot({ moduleUrl: import.meta.url });
-    if (packageRoot === null)
-        return null;
-    for (const candidate of [
-        join(packageRoot, "dist", "esm", "utils", "process-supervisor.js"),
-        join(packageRoot, "src", "utils", "process-supervisor.ts"),
-    ]) {
-        if (existsSync(candidate))
-            return pathToFileURL(candidate).href;
-    }
-    return null;
-}
-function forceReclaimProbe(pid) {
-    if (!Number.isInteger(pid) || pid <= 0)
-        return;
-    const target = process.platform === "win32" ? pid : -pid;
-    try {
-        process.kill(target, "SIGKILL");
-    }
-    catch (error) {
-        if (error.code !== "ESRCH")
-            throw error;
-        return;
-    }
-    const deadline = Date.now() + RTK_PROBE_FORCE_KILL_OBSERVE_MS;
-    const sleeper = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
-    while (isProcessTargetAlive(target) && Date.now() < deadline) {
-        Atomics.wait(sleeper, 0, 0, 20);
-    }
-}
-function isProcessTargetAlive(target) {
-    try {
-        process.kill(target, 0);
-        return true;
-    }
-    catch (error) {
-        return error.code !== "ESRCH";
-    }
-}
+// Capability probing lives in managed-rtk (absolute binary + `gain --help`).
+// Hermetic tests use setRtkAvailabilityProbeForTest to force wrap/degrade.
 export function setRtkAvailabilityProbeForTest(value) {
     rtkAvailable = value;
 }
@@ -232,11 +43,24 @@ export function resolveOutputPolicy(outputPolicy, filterOutput) {
 function withOptionalRtk(resolution, outputPolicy) {
     if (outputPolicy !== "rtk-filtered")
         return resolution;
-    if (!probeRtkAvailability())
+    // Hermetic test seam: setRtkAvailabilityProbeForTest(true) wraps with bare "rtk".
+    if (rtkAvailable === true) {
+        return {
+            ...resolution,
+            command: "rtk",
+            args: [resolution.command, ...resolution.args],
+        };
+    }
+    if (rtkAvailable === false)
+        return resolution;
+    if (!isManagedRtkAvailable())
+        return resolution;
+    const rtkBin = resolveManagedRtkExecutable();
+    if (!rtkBin)
         return resolution;
     return {
         ...resolution,
-        command: "rtk",
+        command: rtkBin,
         args: [resolution.command, ...resolution.args],
     };
 }

package/dist/esm/utils/package-root.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Locate an installed package's root directory from its bare name.
+ *
+ * The obvious spelling — `require.resolve("<name>/package.json")` — is a trap.
+ * Node honours the target package's `exports` map, and a package that declares
+ * only `"."` (rulesync) makes that throw `ERR_PACKAGE_PATH_NOT_EXPORTED`. Every
+ * caller in this repo wrapped it in `try {} catch { return null }`, so the throw
+ * turned into a silently missing capability rather than a visible failure.
+ *
+ * Resolving the package's exported entry works instead, because any package
+ * meant to be imported has one. From there, walk up to the directory whose
+ * `package.json` actually declares that name — the entry may sit several levels
+ * deep (`<root>/dist/index.cjs`).
+ *
+ * Caveat worth knowing before reusing this: `resolve` runs under the CJS
+ * `require` condition. A package whose every export condition is `import`
+ * (ESM-only, as `@webpresso/agent-kit` itself is) has no entry resolvable this
+ * way at all. Such a package must export a condition-free `"./package.json"`
+ * target instead; this helper cannot rescue it.
+ */
+/** Minimal slice of `NodeRequire` needed here — keeps callers and tests honest. */
+export interface ModuleResolver {
+    resolve(specifier: string): string;
+}
+export declare function readPackageManifest(packageRoot: string): Record<string, unknown> | null;
+/**
+ * @param name Bare package name, scoped or unscoped (`rulesync`, `@scope/pkg`).
+ * @returns The package root directory, or `null` when it cannot be resolved.
+ */
+export declare function resolvePackageRoot(name: string, resolver: ModuleResolver, maxDepth?: number): string | null;
+/** Convenience wrapper: the installed `version` of `name`, or `null`. */
+export declare function resolvePackageVersion(name: string, resolver: ModuleResolver): string | null;

package/dist/esm/utils/package-root.js

@@ -0,0 +1,82 @@
+/**
+ * Locate an installed package's root directory from its bare name.
+ *
+ * The obvious spelling — `require.resolve("<name>/package.json")` — is a trap.
+ * Node honours the target package's `exports` map, and a package that declares
+ * only `"."` (rulesync) makes that throw `ERR_PACKAGE_PATH_NOT_EXPORTED`. Every
+ * caller in this repo wrapped it in `try {} catch { return null }`, so the throw
+ * turned into a silently missing capability rather than a visible failure.
+ *
+ * Resolving the package's exported entry works instead, because any package
+ * meant to be imported has one. From there, walk up to the directory whose
+ * `package.json` actually declares that name — the entry may sit several levels
+ * deep (`<root>/dist/index.cjs`).
+ *
+ * Caveat worth knowing before reusing this: `resolve` runs under the CJS
+ * `require` condition. A package whose every export condition is `import`
+ * (ESM-only, as `@webpresso/agent-kit` itself is) has no entry resolvable this
+ * way at all. Such a package must export a condition-free `"./package.json"`
+ * target instead; this helper cannot rescue it.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+const DEFAULT_MAX_WALK_DEPTH = 8;
+export function readPackageManifest(packageRoot) {
+    const manifestPath = join(packageRoot, "package.json");
+    if (!existsSync(manifestPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(manifestPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function declaresPackageName(packageRoot, name) {
+    return readPackageManifest(packageRoot)?.name === name;
+}
+/**
+ * @param name Bare package name, scoped or unscoped (`rulesync`, `@scope/pkg`).
+ * @returns The package root directory, or `null` when it cannot be resolved.
+ */
+export function resolvePackageRoot(name, resolver, maxDepth = DEFAULT_MAX_WALK_DEPTH) {
+    let dir;
+    try {
+        // Prefer the explicit manifest subpath when the package exports it, since
+        // that lands on the root directly; fall back to the package entry.
+        dir = dirname(resolveFirst(resolver, [`${name}/package.json`, name]));
+    }
+    catch {
+        return null;
+    }
+    for (let depth = 0; depth < maxDepth; depth += 1) {
+        // Skip nested manifests (a bundled dependency) until the name matches.
+        if (declaresPackageName(dir, name))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
+function resolveFirst(resolver, specifiers) {
+    let lastError;
+    for (const specifier of specifiers) {
+        try {
+            return resolver.resolve(specifier);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`Cannot resolve ${specifiers[0]}`);
+}
+/** Convenience wrapper: the installed `version` of `name`, or `null`. */
+export function resolvePackageVersion(name, resolver) {
+    const root = resolvePackageRoot(name, resolver);
+    if (!root)
+        return null;
+    const version = readPackageManifest(root)?.version;
+    return typeof version === "string" ? version : null;
+}

package/dist/esm/worktrees/git-metadata.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Git-level worktree admin metadata reconciliation.
+ *
+ * agent-kit keeps its own managed worktree registry, but git keeps a SEPARATE
+ * admin record per linked worktree under `.git/worktrees/<id>`. Deleting a
+ * worktree directory by hand (`rm -rf`) leaves that git record behind, still
+ * claiming the branch it was checked out on — so a later `git checkout <branch>`
+ * fails with `'<branch>' is already used by worktree at <deleted path>` and the
+ * registry-only prune cannot clear it.
+ *
+ * Only `git worktree prune` drops those records, so every agent-kit prune path
+ * runs it BEFORE reading git liveness: a stale record otherwise reports the
+ * deleted path as live and pins the matching registry entry in place too.
+ */
+/** Minimal shape needed from a `git worktree list --porcelain` entry. */
+export interface PrunableWorktreeCandidate {
+    readonly path: string;
+    readonly prunable?: boolean;
+}
+export interface GitWorktreeMetadataPruneResult {
+    /** Paths git reported as prunable immediately before the prune ran. */
+    readonly prunedPaths: readonly string[];
+    /** Non-null when `git worktree prune` itself failed; nothing was reconciled. */
+    readonly error: string | null;
+}
+/**
+ * Clear git's stale linked-worktree admin records for `repoRoot`.
+ *
+ * `entries` is the caller's already-fetched porcelain listing and is used only
+ * to report WHICH paths were cleared; the prune itself is unconditional so a
+ * missing or stale listing can never leave a wedged branch behind.
+ */
+export declare function pruneStaleGitWorktreeMetadata(repoRoot: string, entries?: readonly PrunableWorktreeCandidate[]): GitWorktreeMetadataPruneResult;
+/**
+ * True when `path` no longer has a usable working tree on disk — either git
+ * already flagged the entry prunable, or the directory itself is gone.
+ *
+ * A missing directory makes `git status` fail, which dirty checks would
+ * otherwise report as "uncommitted changes" and refuse to act on.
+ */
+export declare function isStaleWorktreeRegistration(candidate: PrunableWorktreeCandidate | undefined, path: string, directoryExists: (target: string) => boolean): boolean;

package/dist/esm/worktrees/git-metadata.js

@@ -0,0 +1,48 @@
+/**
+ * Git-level worktree admin metadata reconciliation.
+ *
+ * agent-kit keeps its own managed worktree registry, but git keeps a SEPARATE
+ * admin record per linked worktree under `.git/worktrees/<id>`. Deleting a
+ * worktree directory by hand (`rm -rf`) leaves that git record behind, still
+ * claiming the branch it was checked out on — so a later `git checkout <branch>`
+ * fails with `'<branch>' is already used by worktree at <deleted path>` and the
+ * registry-only prune cannot clear it.
+ *
+ * Only `git worktree prune` drops those records, so every agent-kit prune path
+ * runs it BEFORE reading git liveness: a stale record otherwise reports the
+ * deleted path as live and pins the matching registry entry in place too.
+ */
+import { spawnSync } from "node:child_process";
+const GIT_PRUNE_TIMEOUT_MS = 10_000;
+/**
+ * Clear git's stale linked-worktree admin records for `repoRoot`.
+ *
+ * `entries` is the caller's already-fetched porcelain listing and is used only
+ * to report WHICH paths were cleared; the prune itself is unconditional so a
+ * missing or stale listing can never leave a wedged branch behind.
+ */
+export function pruneStaleGitWorktreeMetadata(repoRoot, entries = []) {
+    const prunedPaths = entries.filter((entry) => entry.prunable === true).map((entry) => entry.path);
+    const pruned = spawnSync("git", ["worktree", "prune"], {
+        cwd: repoRoot,
+        encoding: "utf8",
+        // Bounded like every other external probe here: this is a fast local
+        // metadata rewrite, so exceeding the bound means git is wedged, not slow.
+        timeout: GIT_PRUNE_TIMEOUT_MS,
+    });
+    if (pruned.status !== 0) {
+        const detail = String(pruned.stderr || pruned.stdout || "").trim();
+        return { prunedPaths: [], error: detail || "git worktree prune failed" };
+    }
+    return { prunedPaths, error: null };
+}
+/**
+ * True when `path` no longer has a usable working tree on disk — either git
+ * already flagged the entry prunable, or the directory itself is gone.
+ *
+ * A missing directory makes `git status` fail, which dirty checks would
+ * otherwise report as "uncommitted changes" and refuse to act on.
+ */
+export function isStaleWorktreeRegistration(candidate, path, directoryExists) {
+    return candidate?.prunable === true || !directoryExists(path);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpresso/agent-kit",
-  "version": "3.3.3",
+  "version": "3.3.5",
   "private": false,
   "description": "TypeScript-first agent harness for guarded develop/deploy workflows: wp CLI gates, MCP tools, hooks, memory, worktrees, secrets, audits, and evidence checks.",
   "keywords": [
@@ -300,12 +300,7 @@
         "default": "./dist/esm/local.js"
       }
     },
-    "./oxlint": {
-      "import": {
-        "types": "./dist/esm/config/oxlint/index.d.ts",
-        "default": "./dist/esm/config/oxlint/index.js"
-      }
-    },
+    "./package.json": "./package.json",
     "./symlinker": {
       "import": {
         "types": "./dist/esm/symlinker/index.d.ts",
@@ -355,7 +350,7 @@
   },
   "scripts": {
     "setup:agent": "./bin/wp setup",
-    "build": "tshy && ./bin/wp format --file package.json && bun src/build/blueprint-migration-assets.ts && bun src/build/sast-rule-assets.ts && bun src/build/generate-oxlintrc.ts && bun src/build/normalize-tsconfig-json-exports.ts && vp run chmod-bins",
+    "build": "pnpm --filter @webpresso/agent-core run build && pnpm --filter @webpresso/agent-config run build && tshy && ./bin/wp format --file package.json && bun src/build/blueprint-migration-assets.ts && bun src/build/sast-rule-assets.ts && bun src/build/generate-oxlintrc.ts && bun src/build/vendor-oxlint-plugins.ts && bun src/build/normalize-tsconfig-json-exports.ts && vp run chmod-bins",
     "build:runtime-binaries": "bun scripts/build-runtime-binaries.ts",
     "bench:hooks": "bun scripts/bench-hooks.ts",
     "stage:plugin-runtime": "bun scripts/stage-plugin-runtime-artifacts.ts",
@@ -446,7 +441,7 @@
     "ora": "^9.4.1",
     "proper-lockfile": "^4.1.2",
     "react": "^19.2.7",
-    "rulesync": "14.0.1",
+    "rulesync": "15.0.0",
     "secretlint": "^13.0.2",
     "typescript": "^7.0.2",
     "yaml": "^2.9.0",
@@ -490,7 +485,7 @@
       "./e2e-preset/playwright": "./src/config/e2e-preset/playwright.ts",
       "./format": "./src/format/index.ts",
       "./local": "./src/local.ts",
-      "./oxlint": "./src/config/oxlint/index.ts",
+      "./package.json": "./package.json",
       "./symlinker": "./src/symlinker/index.ts",
       "./test": "./src/test/index.ts",
       "./test-preset": "./src/config/test-preset/index.ts",
@@ -519,16 +514,16 @@
     "setupWpActionRef": "c2c71a7a4be446fc6858e6b57bf55a11ccfa2d88"
   },
   "optionalDependencies": {
-    "@webpresso/agent-kit-runtime-darwin-arm64": "3.3.3",
-    "@webpresso/agent-kit-runtime-darwin-x64": "3.3.3",
-    "@webpresso/agent-kit-runtime-linux-x64": "3.3.3",
-    "@webpresso/agent-kit-runtime-linux-arm64": "3.3.3",
-    "@webpresso/agent-kit-runtime-windows-x64": "3.3.3",
-    "@webpresso/agent-kit-session-memory-darwin-x64": "3.3.3",
-    "@webpresso/agent-kit-session-memory-darwin-arm64": "3.3.3",
-    "@webpresso/agent-kit-session-memory-linux-x64": "3.3.3",
-    "@webpresso/agent-kit-session-memory-linux-arm64": "3.3.3",
-    "@webpresso/agent-kit-session-memory-win32-x64": "3.3.3",
-    "@webpresso/agent-kit-session-memory-win32-arm64": "3.3.3"
+    "@webpresso/agent-kit-runtime-darwin-arm64": "3.3.5",
+    "@webpresso/agent-kit-runtime-darwin-x64": "3.3.5",
+    "@webpresso/agent-kit-runtime-linux-x64": "3.3.5",
+    "@webpresso/agent-kit-runtime-linux-arm64": "3.3.5",
+    "@webpresso/agent-kit-runtime-windows-x64": "3.3.5",
+    "@webpresso/agent-kit-session-memory-darwin-x64": "3.3.5",
+    "@webpresso/agent-kit-session-memory-darwin-arm64": "3.3.5",
+    "@webpresso/agent-kit-session-memory-linux-x64": "3.3.5",
+    "@webpresso/agent-kit-session-memory-linux-arm64": "3.3.5",
+    "@webpresso/agent-kit-session-memory-win32-x64": "3.3.5",
+    "@webpresso/agent-kit-session-memory-win32-arm64": "3.3.5"
   }
 }

package/dist/esm/cli/commands/init/scaffolders/subagents/index.d.ts

@@ -1,6 +0,0 @@
-import type { MergeOptions, MergeResult } from "#cli/commands/init/merge";
-export interface ScaffoldSubagentsInput {
-    repoRoot: string;
-    options: MergeOptions;
-}
-export declare function scaffoldSubagents(input: ScaffoldSubagentsInput): MergeResult[];

package/dist/esm/cli/commands/init/scaffolders/subagents/index.js

@@ -1,77 +0,0 @@
-import { existsSync, lstatSync, mkdirSync, readdirSync, readlinkSync, rmSync, symlinkSync, } from "node:fs";
-import { dirname, join, relative } from "node:path";
-import { readPackageJson } from "#cli/commands/init/detect-consumer";
-import { resolveAgentKitPackageRootOrThrow } from "#cli/commands/init/package-root";
-function detectMode(repoRoot) {
-    const pkg = readPackageJson(repoRoot).info;
-    if (pkg?.name === "@webpresso/agent-kit") {
-        return {
-            mode: "self",
-            sourceRoot: join(repoRoot, "catalog", "agent", "agents"),
-        };
-    }
-    const installedPackageJsonPath = join(repoRoot, "node_modules", "@webpresso", "agent-kit", "package.json");
-    const installedAgentsRoot = join(repoRoot, "node_modules", "@webpresso", "agent-kit", "catalog", "agent", "agents");
-    if (existsSync(installedPackageJsonPath) && existsSync(installedAgentsRoot)) {
-        return {
-            mode: "consumer",
-            sourceRoot: installedAgentsRoot,
-        };
-    }
-    return {
-        mode: "package-fallback",
-        sourceRoot: join(resolveCurrentPackageRoot(), "catalog", "agent", "agents"),
-    };
-}
-function resolveCurrentPackageRoot() {
-    return resolveAgentKitPackageRootOrThrow("wp init: could not locate the webpresso package root for subagents fallback.", { requireCatalog: true });
-}
-export function scaffoldSubagents(input) {
-    const { repoRoot, options } = input;
-    const mode = detectMode(repoRoot);
-    const sourceRoot = mode.sourceRoot;
-    const targetRoot = join(repoRoot, ".claude", "agents");
-    const results = [];
-    if (!existsSync(sourceRoot))
-        return results;
-    const entries = readdirSync(sourceRoot).filter((f) => f.endsWith(".md") && f !== "README.md");
-    if (entries.length === 0)
-        return results;
-    if (!options.dryRun) {
-        mkdirSync(targetRoot, { recursive: true });
-    }
-    for (const name of entries) {
-        const sourcePath = join(sourceRoot, name);
-        const targetPath = join(targetRoot, name);
-        const symTarget = relative(dirname(targetPath), sourcePath);
-        if (options.dryRun) {
-            results.push({ targetPath, action: "created" });
-            continue;
-        }
-        try {
-            const stat = lstatSync(targetPath);
-            if (stat.isSymbolicLink()) {
-                const currentTarget = readlinkSync(targetPath);
-                if (currentTarget === symTarget) {
-                    results.push({ targetPath, action: "identical" });
-                }
-                else if (options.overwrite) {
-                    rmSync(targetPath);
-                    symlinkSync(symTarget, targetPath);
-                    results.push({ targetPath, action: "overwritten" });
-                }
-                else {
-                    results.push({ targetPath, action: "drifted" });
-                }
-            }
-            else {
-                results.push({ targetPath, action: "identical" });
-            }
-        }
-        catch {
-            symlinkSync(symTarget, targetPath);
-            results.push({ targetPath, action: "created" });
-        }
-    }
-    return results;
-}

package/dist/esm/config/oxlint/code-safety.d.ts

@@ -1,18 +0,0 @@
-declare const plugin: {
-    meta: {
-        name: string;
-    };
-    rules: {
-        "as-any-audit": {
-            create(context: any): {
-                TSAsExpression(node: any): void;
-            };
-        };
-        "no-swallowed-errors": {
-            create(context: any): {
-                CatchClause(node: any): void;
-            };
-        };
-    };
-};
-export default plugin;

package/dist/esm/config/oxlint/foundation-purity.d.ts

@@ -1,21 +0,0 @@
-declare const plugin: {
-    meta: {
-        name: string;
-    };
-    rules: {
-        "no-framework-imports": {
-            create(context: any): {
-                ImportDeclaration?: undefined;
-                ExportNamedDeclaration?: undefined;
-                ExportAllDeclaration?: undefined;
-                ImportExpression?: undefined;
-            } | {
-                ImportDeclaration(node: any): void;
-                ExportNamedDeclaration(node: any): void;
-                ExportAllDeclaration(node: any): void;
-                ImportExpression(node: any): void;
-            };
-        };
-    };
-};
-export default plugin;

package/dist/esm/config/oxlint/graphql-conventions.d.ts

@@ -1,23 +0,0 @@
-declare const plugin: {
-    meta: {
-        name: string;
-    };
-    rules: {
-        "no-singular-graphql-fields": {
-            create(context: any): {
-                TemplateLiteral(node: any): void;
-                Literal(node: any): void;
-            };
-        };
-        "no-inline-graphql-in-app": {
-            create(context: any): {
-                TaggedTemplateExpression?: undefined;
-                TemplateLiteral?: undefined;
-            } | {
-                TaggedTemplateExpression(node: any): void;
-                TemplateLiteral(node: any): void;
-            };
-        };
-    };
-};
-export default plugin;