@treeseed/sdk 0.11.0 → 0.12.4

package/dist/treeseed/template-catalog/catalog.fixture.json

@@ -22,7 +22,7 @@
       "publisher": {
         "id": "treeseed",
         "name": "TreeSeed",
-        "url": "https://treeseed.ai"
+        "url": "https://treeseed.dev"
       },
       "publisherVerified": true,
       "templateVersion": "1.0.0",
@@ -206,7 +206,7 @@
       "publisher": {
         "id": "treeseed",
         "name": "TreeSeed",
-        "url": "https://treeseed.ai"
+        "url": "https://treeseed.dev"
       },
       "publisherVerified": true,
       "templateVersion": "1.0.0",
@@ -390,7 +390,7 @@
       "publisher": {
         "id": "treeseed",
         "name": "TreeSeed",
-        "url": "https://treeseed.ai"
+        "url": "https://treeseed.dev"
       },
       "publisherVerified": true,
       "templateVersion": "1.0.0",
@@ -574,7 +574,7 @@
       "publisher": {
         "id": "treeseed",
         "name": "TreeSeed",
-        "url": "https://treeseed.ai"
+        "url": "https://treeseed.dev"
       },
       "publisherVerified": true,
       "templateVersion": "0.1.0",

package/dist/types/agents.d.ts

@@ -4,12 +4,22 @@ export declare const AGENT_MESSAGE_STATUSES: readonly ["pending", "claimed", "co
 export declare const AGENT_RUN_STATUSES: readonly ["running", "completed", "failed", "waiting"];
 export declare const AGENT_HANDLER_KINDS: readonly ["planner", "architect", "engineer", "notifier", "researcher", "reviewer", "releaser"];
 export declare const AGENT_CLI_ALLOW_TOOLS: readonly ["shell(git)", "shell(npm)", "web"];
+export declare const EXECUTION_RESOURCE_NEED_KINDS: readonly ["repository", "treedx_workspace", "workflow", "secret", "external_issue", "external_job"];
+export declare const EXECUTION_PROVIDER_KINDS: readonly ["ai_model", "human_issue_queue", "deterministic_workflow", "local_process"];
+export declare const EXECUTION_RUN_STATUSES: readonly ["accepted", "running", "waiting", "blocked", "completed", "returned", "failed", "cancelled"];
+export declare const EXECUTION_PROVIDER_PRESSURE_STATES: readonly ["idle", "normal", "busy", "throttled", "exhausted"];
+export declare const EXECUTION_PROVIDER_QUOTA_VISIBILITIES: readonly ["opaque", "partial", "exact"];
 export type AgentTriggerKind = (typeof AGENT_TRIGGER_KINDS)[number];
 export type AgentPermissionOperation = (typeof AGENT_PERMISSION_OPERATIONS)[number];
 export type AgentMessageStatus = (typeof AGENT_MESSAGE_STATUSES)[number];
 export type AgentRunStatus = (typeof AGENT_RUN_STATUSES)[number];
 export type AgentHandlerKind = string;
 export type AgentCliAllowTool = (typeof AGENT_CLI_ALLOW_TOOLS)[number];
+export type ExecutionResourceNeedKind = (typeof EXECUTION_RESOURCE_NEED_KINDS)[number] | string;
+export type ExecutionProviderKind = (typeof EXECUTION_PROVIDER_KINDS)[number] | string;
+export type ExecutionRunStatus = (typeof EXECUTION_RUN_STATUSES)[number];
+export type ExecutionProviderPressure = (typeof EXECUTION_PROVIDER_PRESSURE_STATES)[number];
+export type ExecutionProviderQuotaVisibility = (typeof EXECUTION_PROVIDER_QUOTA_VISIBILITIES)[number];
 export interface AgentTriggerConfig {
     type: AgentTriggerKind;
     cron?: string;
@@ -22,10 +32,58 @@ export interface AgentPermissionConfig {
     model: string;
     operations: AgentPermissionOperation[];
 }
+export interface AgentContentPermission {
+    model: string;
+    operations: Array<'read' | 'create' | 'update' | 'link' | 'comment' | string>;
+    filters?: Record<string, unknown>;
+}
+export interface AgentModePermissionPolicy {
+    content?: {
+        read?: AgentContentPermission[];
+        write?: AgentContentPermission[];
+    };
+    repository?: {
+        readPaths?: string[];
+        writePaths?: string[];
+        allowCodeMutation?: boolean;
+    };
+    network?: {
+        allowWeb?: boolean;
+        allowedDomains?: string[];
+    };
+    shell?: {
+        allowCommands?: boolean;
+        allowedCommands?: string[];
+        deniedCommands?: string[];
+    };
+}
+export interface AgentPermissionPolicy {
+    modes?: {
+        planning?: AgentModePermissionPolicy;
+        acting?: AgentModePermissionPolicy;
+    };
+}
 export interface AgentOutputContract {
     messageTypes: string[];
     modelMutations: string[];
 }
+export interface AgentToolPolicy {
+    allowed: string[];
+}
+export interface AgentContentScope {
+    models: string[];
+    actions?: import('../content-operations.js').TreeseedContentAction[];
+    books?: string[];
+    paths?: string[];
+    relations?: string[];
+}
+export interface AgentContentAccessPolicy {
+    read?: AgentContentScope;
+    write?: AgentContentScope;
+    commit?: {
+        allowed: boolean;
+    };
+}
 export interface AgentExecutionConfig {
     provider?: string;
     model?: string;
@@ -73,6 +131,195 @@ export interface AgentProviderProfile {
     disallowedRegions?: string[];
     fallbackPolicy: AgentProviderFallbackPolicy;
 }
+export interface ExecutionResourceNeed {
+    kind: ExecutionResourceNeedKind;
+    operations: string[];
+    paths?: string[];
+    required?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionCapabilityDemand {
+    required: string[];
+    preferred?: string[];
+    mode: 'planning' | 'acting';
+    resourceNeeds?: ExecutionResourceNeed[];
+    outputTypes?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionCapabilitySupply {
+    capacityProviderId: string;
+    executionProviderId: string;
+    kind: ExecutionProviderKind;
+    capabilities: string[];
+    aliases?: string[];
+    grants: string[];
+    availability?: Record<string, unknown>;
+    pressure?: ExecutionProviderPressure;
+    maxConcurrentAssignments?: number;
+    nativeUnit?: string;
+    quotaVisibility?: ExecutionProviderQuotaVisibility;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentExpectedOutput {
+    type: string;
+    required: boolean;
+    description?: string;
+    schema?: Record<string, unknown>;
+}
+export interface AgentWorkPackageConstraints {
+    mode: 'planning' | 'acting';
+    requiredCapabilities: string[];
+    allowedPaths?: string[];
+    forbiddenPaths?: string[];
+    allowedOperations?: string[];
+    deadline?: string | null;
+    maxAttempts?: number | null;
+    metadata?: Record<string, unknown>;
+}
+export type AgentHandlerAlgorithmKind = 'plan' | 'research' | 'act' | 'review' | 'report';
+export type AgentWorkPackageKind = AgentHandlerAlgorithmKind | string;
+export interface AgentInputSelector {
+    source: string;
+    path?: string;
+    required?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentOutputTemplate {
+    type: string;
+    template?: string;
+    required?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentReviewCriterion {
+    id: string;
+    description: string;
+    required?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentPlanningPolicy {
+    prioritization?: string;
+    maxCandidates?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentReportTemplate {
+    kind: string;
+    title?: string;
+    sections?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface AgentHandlerConfig {
+    workPackageKind?: AgentWorkPackageKind;
+    domain?: string;
+    inputSelectors?: AgentInputSelector[];
+    outputTemplates?: AgentOutputTemplate[];
+    reviewCriteria?: AgentReviewCriterion[];
+    planningPolicy?: AgentPlanningPolicy;
+    reportTemplate?: AgentReportTemplate;
+    delegation?: {
+        required?: boolean;
+        allowedProviderKinds?: string[];
+        reason?: string;
+    };
+    resourceNeeds?: ExecutionResourceNeed[];
+    metadata?: Record<string, unknown>;
+}
+export interface AgentWorkPackage {
+    kind: AgentWorkPackageKind;
+    title: string;
+    summary: string;
+    instructions: string;
+    context: Record<string, unknown>;
+    expectedOutputs: AgentExpectedOutput[];
+    constraints: AgentWorkPackageConstraints;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionProviderDescriptor {
+    id: string;
+    kind: ExecutionProviderKind;
+    capabilities: string[];
+    capabilityAliases?: string[];
+    nativeUnit: string;
+    quotaVisibility: ExecutionProviderQuotaVisibility;
+    maxConcurrentAssignments: number;
+    supportsAsync: boolean;
+    supportsCancel: boolean;
+    supportsResume: boolean;
+    supportsUsage: boolean;
+    supportsArtifacts: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionProviderObserveInput {
+    capacityProviderId?: string | null;
+    executionProviderId?: string | null;
+    runnerId?: string | null;
+    activeAssignmentIds?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionProviderObservation {
+    descriptor?: ExecutionProviderDescriptor;
+    supply?: ExecutionCapabilitySupply;
+    pressure?: ExecutionProviderPressure;
+    available?: boolean;
+    activeAssignmentCount?: number;
+    blockedReason?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionPreparationResult {
+    accepted: boolean;
+    summary: string;
+    retryable?: boolean;
+    code?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionRunRef {
+    assignmentId: string;
+    executionProviderId?: string | null;
+    runId: string;
+    externalRef?: string | null;
+    externalUrl?: string | null;
+    leaseToken?: string | null;
+    runnerId?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionUsageActual {
+    kind: string;
+    unit: string;
+    amount: number;
+    source?: string | null;
+    partial?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionArtifactRef {
+    kind: string;
+    name?: string | null;
+    uri?: string | null;
+    externalUrl?: string | null;
+    mediaType?: string | null;
+    digest?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionWorkspaceContext {
+    repoRoot?: string | null;
+    workspaceId?: string | null;
+    accessMode?: string | null;
+    allowedPaths?: string[];
+    forbiddenPaths?: string[];
+    capabilityHandleIds?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface ExecutionRunSnapshot {
+    status: ExecutionRunStatus;
+    summary: string;
+    runId?: string | null;
+    externalRef?: string | null;
+    externalUrl?: string | null;
+    outputs?: Record<string, unknown>;
+    usage?: ExecutionUsageActual[];
+    artifacts?: ExecutionArtifactRef[];
+    retryable?: boolean;
+    code?: string | null;
+    metadata?: Record<string, unknown>;
+}
 export interface AgentTriggerPolicy {
     maxRunsPerCycle?: number;
     messageBatchSize?: number;
@@ -85,6 +332,9 @@ export interface AgentCliOptions {
 export interface AgentRuntimeSpec {
     slug: string;
     handler: AgentHandlerKind;
+    projectAgentClassId?: string;
+    projectAgentClassSlug?: string;
+    handlerConfig?: AgentHandlerConfig;
     enabled: boolean;
     systemPrompt: string;
     persona: string;
@@ -92,6 +342,12 @@ export interface AgentRuntimeSpec {
     triggers: AgentTriggerConfig[];
     triggerPolicy?: AgentTriggerPolicy;
     permissions: AgentPermissionConfig[];
+    permissionPolicy?: AgentPermissionPolicy;
+    tools: AgentToolPolicy;
+    contentAccess?: AgentContentAccessPolicy;
+    context?: {
+        queries?: import('../graph/context-query-contracts.js').DeclarativeContextQuery[];
+    };
     execution: AgentExecutionConfig;
     outputs: AgentOutputContract;
 }

package/dist/types/agents.js

@@ -30,11 +30,52 @@ const AGENT_CLI_ALLOW_TOOLS = [
   "shell(npm)",
   "web"
 ];
+const EXECUTION_RESOURCE_NEED_KINDS = [
+  "repository",
+  "treedx_workspace",
+  "workflow",
+  "secret",
+  "external_issue",
+  "external_job"
+];
+const EXECUTION_PROVIDER_KINDS = [
+  "ai_model",
+  "human_issue_queue",
+  "deterministic_workflow",
+  "local_process"
+];
+const EXECUTION_RUN_STATUSES = [
+  "accepted",
+  "running",
+  "waiting",
+  "blocked",
+  "completed",
+  "returned",
+  "failed",
+  "cancelled"
+];
+const EXECUTION_PROVIDER_PRESSURE_STATES = [
+  "idle",
+  "normal",
+  "busy",
+  "throttled",
+  "exhausted"
+];
+const EXECUTION_PROVIDER_QUOTA_VISIBILITIES = [
+  "opaque",
+  "partial",
+  "exact"
+];
 export {
   AGENT_CLI_ALLOW_TOOLS,
   AGENT_HANDLER_KINDS,
   AGENT_MESSAGE_STATUSES,
   AGENT_PERMISSION_OPERATIONS,
   AGENT_RUN_STATUSES,
-  AGENT_TRIGGER_KINDS
+  AGENT_TRIGGER_KINDS,
+  EXECUTION_PROVIDER_KINDS,
+  EXECUTION_PROVIDER_PRESSURE_STATES,
+  EXECUTION_PROVIDER_QUOTA_VISIBILITIES,
+  EXECUTION_RESOURCE_NEED_KINDS,
+  EXECUTION_RUN_STATUSES
 };

package/dist/verification.d.ts

@@ -3,6 +3,7 @@ export type TreeseedVerifyDriverOptions = {
     packageRoot?: string;
     driver?: TreeseedVerifyDriver;
     eventName?: string;
+    localTreeseedExtraSiblingDependencies?: string[];
     write?: (message: string, stream?: 'stdout' | 'stderr') => void;
     runCommand?: (command: string, args: string[], cwd: string) => number;
     checkCommand?: (command: string, args: string[], cwd: string) => {

package/dist/verification.js

@@ -1,10 +1,13 @@
-import { existsSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+#!/usr/bin/env node
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import * as childProcess from "node:child_process";
 import { basename, relative, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createTreeseedManagedToolEnv, resolveTreeseedToolBinary } from "./managed-dependencies.js";
 const defaultActUbuntuLatestImage = "catthehacker/ubuntu:act-latest";
+const actLockStaleAfterMs = 2 * 60 * 60 * 1e3;
+const actLockPollMs = 500;
 function defaultWrite(message, stream = "stdout") {
   if (!message) return;
   (stream === "stderr" ? process.stderr : process.stdout).write(`${message}
@@ -41,14 +44,116 @@ function readPackageManifest(packageJsonPath) {
     return null;
   }
 }
+function allocateActServerPorts() {
+  const result = childProcess.spawnSync(process.execPath, [
+    "-e",
+    `const net = require('node:net');
+const servers = [net.createServer(), net.createServer()];
+const ports = [];
+let remaining = servers.length;
+function fail(error) {
+	console.error(error && error.stack ? error.stack : String(error));
+	process.exit(1);
+}
+for (const server of servers) {
+	server.once('error', fail);
+	server.listen(0, '127.0.0.1', () => {
+		const address = server.address();
+		if (!address || typeof address === 'string') fail(new Error('Unable to allocate TCP port.'));
+		ports.push(address.port);
+		server.close(() => {
+			remaining -= 1;
+			if (remaining === 0) {
+				console.log(JSON.stringify(ports));
+			}
+		});
+	});
+}`
+  ], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.status !== 0) {
+    const detail = `${result.stderr ?? ""}
+${result.stdout ?? ""}`.trim();
+    throw new Error(`Unable to allocate local act server ports.${detail ? `
+${detail}` : ""}`);
+  }
+  const ports = JSON.parse(result.stdout.trim());
+  if (!Array.isArray(ports) || ports.length !== 2 || ports.some((port) => !Number.isInteger(port) || port <= 0)) {
+    throw new Error(`Unable to allocate local act server ports: ${result.stdout.trim()}`);
+  }
+  return {
+    artifactServerPort: String(ports[0]),
+    cacheServerPort: String(ports[1])
+  };
+}
 function createActArgs(eventName, workflowPath) {
   const image = process.env.TREESEED_VERIFY_ACT_UBUNTU_LATEST_IMAGE?.trim() || defaultActUbuntuLatestImage;
-  const args = ["act", eventName, "-W", workflowPath, "-j", "verify"];
+  const ports = allocateActServerPorts();
+  const args = [
+    "act",
+    eventName,
+    "-W",
+    workflowPath,
+    "-j",
+    "verify",
+    "--artifact-server-port",
+    ports.artifactServerPort,
+    "--cache-server-port",
+    ports.cacheServerPort
+  ];
   if (image) {
     args.push("-P", `ubuntu-latest=${image}`);
   }
   return args;
 }
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function acquireActLock() {
+  const lockDir = resolve(tmpdir(), "treeseed-verify-act.lock");
+  const owner = `${process.pid}:${Date.now()}`;
+  while (true) {
+    try {
+      mkdirSync(lockDir);
+      writeFileSync(resolve(lockDir, "owner"), owner, "utf8");
+      return () => {
+        try {
+          const currentOwner = readFileSync(resolve(lockDir, "owner"), "utf8");
+          if (currentOwner === owner) {
+            rmSync(lockDir, { recursive: true, force: true });
+          }
+        } catch {
+        }
+      };
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") {
+        throw error;
+      }
+      try {
+        const ageMs = Date.now() - statSync(lockDir).mtimeMs;
+        if (ageMs > actLockStaleAfterMs) {
+          rmSync(lockDir, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        rmSync(lockDir, { recursive: true, force: true });
+        continue;
+      }
+      sleepSync(actLockPollMs);
+    }
+  }
+}
+function runActCommand(runCommand, command, args, cwd) {
+  const releaseLock = acquireActLock();
+  try {
+    return runCommand(command, args, cwd);
+  } finally {
+    releaseLock();
+  }
+}
 function createWorkspaceActWorkflow(options) {
   const relativePackageRoot = relative(options.workspaceRoot, options.packageRoot).replace(/\\/g, "/");
   const siblingLinkCommands = options.localTreeseedSiblingDependencies.map((packageName) => {
@@ -66,6 +171,20 @@ function createWorkspaceActWorkflow(options) {
       `ln -s ${linkTarget} ${linkParent}/${packageShortName}`
     ].join("\n");
   }).join("\n");
+  const npmRetryFunction = [
+    "treeseed_npm_retry() {",
+    "  attempt=1",
+    '  until npm "$@"; do',
+    "    status=$?",
+    '    if test "$attempt" -ge 3; then',
+    '      return "$status"',
+    "    fi",
+    '    echo "npm $* failed with $status; retrying in $((attempt * 5))s" >&2',
+    "    sleep $((attempt * 5))",
+    "    attempt=$((attempt + 1))",
+    "  done",
+    "}"
+  ].join("\n");
   const siblingPreparationCommands = options.localTreeseedSiblingDependencies.map((packageName) => {
     const packageDir = `packages/${packageName.split("/")[1]}`;
     const manifest = readPackageManifest(resolve(options.workspaceRoot, packageDir, "package.json"));
@@ -74,9 +193,9 @@ function createWorkspaceActWorkflow(options) {
     }
     const commands = [
       `if test -f ${packageDir}/package-lock.json; then`,
-      `  npm --prefix ${packageDir} ci --workspaces=false`,
+      `  treeseed_npm_retry --prefix ${packageDir} ci --workspaces=false`,
       "else",
-      `  npm --prefix ${packageDir} install --workspaces=false --no-audit --no-fund`,
+      `  treeseed_npm_retry --prefix ${packageDir} install --workspaces=false --no-audit --no-fund`,
       "fi"
     ];
     if (manifest.scripts?.["build:dist"]) {
@@ -86,6 +205,7 @@ function createWorkspaceActWorkflow(options) {
   }).filter((command) => Boolean(command)).join("\n");
   const workflowRoot = mkdtempSync(resolve(tmpdir(), "treeseed-verify-act-"));
   const workflowPath = resolve(workflowRoot, "verify.yml");
+  const isolatedPackageVerifyEnv = process.env.TREESEED_VERIFY_PACKAGE_ISOLATED === "1" ? '      TREESEED_VERIFY_PACKAGE_ISOLATED: "1"\n' : "";
   writeFileSync(
     workflowPath,
     `name: Treeseed Local Verify
@@ -104,7 +224,7 @@ jobs:
       TREESEED_STAGE_WAIT_MODE: skip
       TREESEED_AGENT_DISABLE_GIT: "true"
       TREESEED_FIXTURE_ID: treeseed-working-site
-    steps:
+${isolatedPackageVerifyEnv}    steps:
       - name: Checkout
         uses: actions/checkout@v4
         with:
@@ -121,17 +241,21 @@ jobs:
 ${siblingPreparationCommands ? `      - name: Prepare sibling packages
         working-directory: .
         run: |
+${npmRetryFunction.split("\n").map((line) => `          ${line}`).join("\n")}
 ${siblingPreparationCommands.split("\n").map((line) => `          ${line}`).join("\n")}
 
 ` : ""}      - name: Install dependencies
         run: |
+${npmRetryFunction.split("\n").map((line) => `          ${line}`).join("\n")}
           node -e "const fs = require('fs'); const p = JSON.parse(fs.readFileSync('package.json', 'utf8')); if (p.scripts) delete p.scripts.prepare; fs.writeFileSync('package.json', JSON.stringify(p, null, '\\t') + '\\n');"
           if test -f package-lock.json; then
-            npm ci --workspaces=false
+            treeseed_npm_retry ci --workspaces=false
           else
-            npm install --workspaces=false --no-audit --no-fund
+            treeseed_npm_retry install --workspaces=false --no-audit --no-fund
+          fi
+          if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+            git checkout -- package.json
           fi
-          git checkout -- package.json || true
 
 ${siblingLinkCommands ? `      - name: Link local Treeseed dependencies
         run: |
@@ -167,7 +291,7 @@ function findWorkspaceRoot(packageRoot) {
     current = parent;
   }
 }
-function resolveLocalWorkspaceContext(packageRoot) {
+function resolveLocalWorkspaceContext(packageRoot, extraSiblingDependencies = []) {
   const currentManifest = readPackageManifest(resolve(packageRoot, "package.json"));
   const currentPackageName = typeof currentManifest?.name === "string" ? currentManifest.name : null;
   const workspace = findWorkspaceRoot(packageRoot);
@@ -199,7 +323,12 @@ function resolveLocalWorkspaceContext(packageRoot) {
     ...currentPackage.manifest.devDependencies ?? {},
     ...currentPackage.manifest.peerDependencies ?? {}
   };
-  const localTreeseedSiblingDependencies = Object.keys(declaredDependencies).filter((name) => name.startsWith("@treeseed/")).filter((name) => localTreeseedPackageSet.has(name)).sort();
+  const declaredLocalTreeseedSiblingDependencies = Object.keys(declaredDependencies).filter((name) => name.startsWith("@treeseed/")).filter((name) => localTreeseedPackageSet.has(name)).sort();
+  const extraLocalTreeseedSiblingDependencies = extraSiblingDependencies.filter((name) => name.startsWith("@treeseed/")).filter((name) => localTreeseedPackageSet.has(name)).sort();
+  const localTreeseedSiblingDependencies = [
+    ...declaredLocalTreeseedSiblingDependencies,
+    ...extraLocalTreeseedSiblingDependencies.filter((name) => !declaredLocalTreeseedSiblingDependencies.includes(name))
+  ];
   return {
     workspaceRoot: workspace.workspaceRoot,
     currentPackageName: currentPackage.manifest.name ?? currentPackageName,
@@ -214,7 +343,7 @@ function getTreeseedVerifyDriverStatus(options = {}) {
   const eventName = options.eventName ?? process.env.TREESEED_VERIFY_EVENT ?? "workflow_dispatch";
   const inGitHubActions = process.env.GITHUB_ACTIONS === "true";
   const workflowPresent = existsSync(workflowPath);
-  const workspace = resolveLocalWorkspaceContext(packageRoot);
+  const workspace = resolveLocalWorkspaceContext(packageRoot, options.localTreeseedExtraSiblingDependencies ?? []);
   const checkCommand = options.checkCommand ?? check;
   const gh = options.checkCommand ? "gh" : resolveTreeseedToolBinary("gh") ?? "gh";
   const ghAct = checkCommand(gh, ["act", "--version"], packageRoot);
@@ -268,15 +397,15 @@ function runTreeseedVerifyDriver(options = {}) {
         eventName: status.eventName,
         localTreeseedSiblingDependencies: status.localTreeseedSiblingDependencies
       });
-      return runCommand(gh, workspaceAct.args, workspaceAct.cwd);
+      return runActCommand(runCommand, gh, workspaceAct.args, workspaceAct.cwd);
     }
-    return runCommand(gh, createActArgs(status.eventName, ".github/workflows/verify.yml"), status.packageRoot);
+    return runActCommand(runCommand, gh, createActArgs(status.eventName, ".github/workflows/verify.yml"), status.packageRoot);
   }
   if (status.prefersDirectForLocalWorkspace) {
     return runCommand("npm", ["run", "verify:direct"], status.packageRoot);
   }
   if (status.canUseAct) {
-    return runCommand(gh, createActArgs(status.eventName, ".github/workflows/verify.yml"), status.packageRoot);
+    return runActCommand(runCommand, gh, createActArgs(status.eventName, ".github/workflows/verify.yml"), status.packageRoot);
   }
   if (!status.workflowPresent) {
     write("Treeseed verify warning: package-local verify workflow is missing; falling back to verify:direct.", "stderr");