@treeseed/core 0.4.6 → 0.4.8

package/README.md

@@ -1,6 +1,6 @@
 # @treeseed/core
 
-`@treeseed/core` is the Treeseed integrated platform starter for Astro/Starlight sites and Hono API runtimes. It contains the published web runtime, API runtime, integrated local dev orchestration, shared components and styles, the knowledge-factory content model, and the forms stack used by Treeseed tenants.
+`@treeseed/core` is the Treeseed integrated platform starter for Astro/Starlight sites, Hono API runtimes, agent runtimes, and worker services. It contains the published web runtime, API runtime, manager/worker entrypoints, integrated local dev orchestration, shared components and styles, the knowledge-factory content model, and the forms stack used by Treeseed tenants.
 
 This repository is the package root. Run package commands from [`core`](./), not from the top-level `treeseed` workspace.
 
@@ -41,13 +41,7 @@ The package builds directly against the canonical shared working-site fixture in
 
 `@treeseed/core` validates itself against the integrated shared fixture, not a Core-specific fork.
 
-That means:
-
-- the fixture may reference package surfaces owned by `sdk` and `agent`
-- Core does not gain a real dependency on `@treeseed/agent`
-- isolated Core verification may provide an Agent contracts shim so the shared fixture can typecheck and build without the full Agent runtime package
-
-This keeps the shared fixture canonical while preserving Core’s package boundary.
+That means the fixture may reference package surfaces owned by `sdk`, `core`, and `cli`, and isolated Core verification links the real local `core` package into the shared fixture instead of maintaining a separate agent package boundary.
 
 ## Commands
 
@@ -57,6 +51,10 @@ This keeps the shared fixture canonical while preserving Core’s package bounda
 npm run dev
 npm run dev:web
 npm run dev:api
+npm run dev:manager
+npm run dev:worker
+npm run dev:workday-start
+npm run dev:workday-report
 npm run fixtures:check
 npm run build:dist
 npm run test:unit
@@ -70,6 +68,7 @@ What they do:
 - `dev`: starts the integrated Astro UI and Hono API local runtime from `core`
 - `dev:web`: starts only the Astro UI dev surface through the `core` runtime
 - `dev:api`: starts only the Hono API dev surface through the `core` runtime
+- `dev:manager`, `dev:worker`, `dev:workday-start`, `dev:workday-report`: start the worker-service entrypoints from `core`
 - `fixtures:check`: verifies that the pinned shared fixture is initialized and usable
 - `build:dist`: builds the publishable `dist/` package output
 - `test:unit`: runs package unit tests with Vitest
@@ -134,14 +133,7 @@ The published package includes:
 - `utils/`
 - `README.md`
 
-The package currently depends on:
-
-- `@treeseed/sdk`
-- Astro and Starlight runtime packages
-- Tailwind/Vite integration used by the site runtime
-- Wrangler for Cloudflare-oriented runtime and deploy support
-
-It does not depend on `@treeseed/agent`.
+The package currently depends on `@treeseed/sdk` plus the runtime packages needed for its web, API, and worker surfaces. It does not depend on `@treeseed/cli`.
 
 ## Contributor Workflow
 

package/dist/agent-runtime.d.ts

@@ -0,0 +1,17 @@
+import type { AgentExecutionAdapter, AgentHandler, AgentMutationAdapter, AgentNotificationAdapter, AgentRepositoryInspectionAdapter, AgentResearchAdapter, AgentVerificationAdapter } from './agents/runtime-types.ts';
+export declare function resolveAgentRuntimeProviders(repoRoot: string, selections: {
+    execution: string;
+    mutation: string;
+    repository: string;
+    verification: string;
+    notification: string;
+    research: string;
+}): {
+    execution: AgentExecutionAdapter;
+    mutations: AgentMutationAdapter;
+    repository: AgentRepositoryInspectionAdapter;
+    verification: AgentVerificationAdapter;
+    notifications: AgentNotificationAdapter;
+    research: AgentResearchAdapter;
+    handlers: Map<string, AgentHandler<unknown, unknown>>;
+};

package/dist/agent-runtime.js

@@ -0,0 +1,111 @@
+import { loadTreeseedPluginRuntime } from "@treeseed/sdk/platform/plugins";
+import {
+  CopilotExecutionAdapter,
+  ManualExecutionAdapter,
+  StubExecutionAdapter
+} from "./agents/adapters/execution.js";
+import { LocalBranchMutationAdapter } from "./agents/adapters/mutations.js";
+import { StubNotificationAdapter } from "./agents/adapters/notification.js";
+import { GitRepositoryInspectionAdapter, StubRepositoryInspectionAdapter } from "./agents/adapters/repository.js";
+import { StubResearchAdapter } from "./agents/adapters/research.js";
+import { LocalVerificationAdapter, StubVerificationAdapter } from "./agents/adapters/verification.js";
+let cachedAgentRuntime = null;
+function readPluginRecord(pluginEntry, key) {
+  const value = pluginEntry.plugin[key];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function assertUniqueProvider(registry, id, owner) {
+  if (registry.has(id)) {
+    throw new Error(`Treeseed plugin runtime found duplicate provider "${id}" from ${owner}.`);
+  }
+}
+function collectAgentHandlersFromPlugin(pluginEntry, registry) {
+  const contributedHandlers = readPluginRecord(pluginEntry, "agentHandlers");
+  for (const [id, handler] of Object.entries(contributedHandlers)) {
+    assertUniqueProvider(registry, id, pluginEntry.package);
+    registry.set(id, handler);
+  }
+}
+function buildAgentRuntime() {
+  const runtime = loadTreeseedPluginRuntime();
+  const execution = /* @__PURE__ */ new Map([
+    ["stub", () => new StubExecutionAdapter()],
+    ["manual", () => new ManualExecutionAdapter()],
+    ["copilot", () => new CopilotExecutionAdapter()]
+  ]);
+  const mutation = /* @__PURE__ */ new Map([
+    ["local_branch", (repoRoot) => new LocalBranchMutationAdapter(repoRoot)]
+  ]);
+  const repository = /* @__PURE__ */ new Map([
+    ["stub", () => new StubRepositoryInspectionAdapter()],
+    ["git", () => new GitRepositoryInspectionAdapter()]
+  ]);
+  const verification = /* @__PURE__ */ new Map([
+    ["stub", () => new StubVerificationAdapter()],
+    ["local", () => new LocalVerificationAdapter()]
+  ]);
+  const notification = /* @__PURE__ */ new Map([["stub", () => new StubNotificationAdapter()]]);
+  const research = /* @__PURE__ */ new Map([["stub", () => new StubResearchAdapter()]]);
+  const handlers = /* @__PURE__ */ new Map();
+  for (const pluginEntry of runtime.plugins) {
+    const agentProviders = readPluginRecord(pluginEntry, "agentProviders");
+    for (const [id, factory] of Object.entries(agentProviders.execution ?? {})) {
+      assertUniqueProvider(execution, id, pluginEntry.package);
+      execution.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(agentProviders.mutation ?? {})) {
+      assertUniqueProvider(mutation, id, pluginEntry.package);
+      mutation.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(agentProviders.repository ?? {})) {
+      assertUniqueProvider(repository, id, pluginEntry.package);
+      repository.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(agentProviders.verification ?? {})) {
+      assertUniqueProvider(verification, id, pluginEntry.package);
+      verification.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(agentProviders.notification ?? {})) {
+      assertUniqueProvider(notification, id, pluginEntry.package);
+      notification.set(id, factory);
+    }
+    for (const [id, factory] of Object.entries(agentProviders.research ?? {})) {
+      assertUniqueProvider(research, id, pluginEntry.package);
+      research.set(id, factory);
+    }
+    collectAgentHandlersFromPlugin(pluginEntry, handlers);
+  }
+  return {
+    providers: { execution, mutation, repository, verification, notification, research },
+    handlers
+  };
+}
+function resolveAgentRuntimeProviders(repoRoot, selections) {
+  if (!cachedAgentRuntime) {
+    cachedAgentRuntime = buildAgentRuntime();
+  }
+  const executionFactory = cachedAgentRuntime.providers.execution.get(selections.execution);
+  const mutationFactory = cachedAgentRuntime.providers.mutation.get(selections.mutation);
+  const repositoryFactory = cachedAgentRuntime.providers.repository.get(selections.repository);
+  const verificationFactory = cachedAgentRuntime.providers.verification.get(selections.verification);
+  const notificationFactory = cachedAgentRuntime.providers.notification.get(selections.notification);
+  const researchFactory = cachedAgentRuntime.providers.research.get(selections.research);
+  if (!executionFactory) throw new Error(`Treeseed agent execution provider "${selections.execution}" is not registered.`);
+  if (!mutationFactory) throw new Error(`Treeseed agent mutation provider "${selections.mutation}" is not registered.`);
+  if (!repositoryFactory) throw new Error(`Treeseed agent repository provider "${selections.repository}" is not registered.`);
+  if (!verificationFactory) throw new Error(`Treeseed agent verification provider "${selections.verification}" is not registered.`);
+  if (!notificationFactory) throw new Error(`Treeseed agent notification provider "${selections.notification}" is not registered.`);
+  if (!researchFactory) throw new Error(`Treeseed agent research provider "${selections.research}" is not registered.`);
+  return {
+    execution: executionFactory(),
+    mutations: mutationFactory(repoRoot),
+    repository: repositoryFactory(),
+    verification: verificationFactory(),
+    notifications: notificationFactory(),
+    research: researchFactory(),
+    handlers: cachedAgentRuntime.handlers
+  };
+}
+export {
+  resolveAgentRuntimeProviders
+};

package/dist/agent.d.ts

@@ -0,0 +1,11 @@
+export { AgentKernel } from './agents/kernel/agent-kernel.ts';
+export { listTreeseedAgentCommands, renderTreeseedAgentHelp, runTreeseedAgentCli } from './agents/cli.ts';
+export { resolveAgentHandler, listRegisteredAgentHandlers } from './agents/registry.ts';
+export { resolveAgentRuntimeProviders } from './agent-runtime.ts';
+export { createManagerApp } from './services/manager.ts';
+export { runWorkerCycle, startWorkerLoop } from './services/worker.ts';
+export { runWorkdayStart } from './services/workday-start.ts';
+export { runWorkdayReport } from './services/workday-report.ts';
+export { parseAgentMessagePayload, AGENT_MESSAGE_TYPES } from './agents/contracts/messages.ts';
+export type * from './agents/runtime-types.ts';
+export type * from './agents/contracts/run.ts';

package/dist/agent.js

@@ -0,0 +1,25 @@
+import { AgentKernel } from "./agents/kernel/agent-kernel.js";
+import { listTreeseedAgentCommands, renderTreeseedAgentHelp, runTreeseedAgentCli } from "./agents/cli.js";
+import { resolveAgentHandler, listRegisteredAgentHandlers } from "./agents/registry.js";
+import { resolveAgentRuntimeProviders } from "./agent-runtime.js";
+import { createManagerApp } from "./services/manager.js";
+import { runWorkerCycle, startWorkerLoop } from "./services/worker.js";
+import { runWorkdayStart } from "./services/workday-start.js";
+import { runWorkdayReport } from "./services/workday-report.js";
+import { parseAgentMessagePayload, AGENT_MESSAGE_TYPES } from "./agents/contracts/messages.js";
+export {
+  AGENT_MESSAGE_TYPES,
+  AgentKernel,
+  createManagerApp,
+  listRegisteredAgentHandlers,
+  listTreeseedAgentCommands,
+  parseAgentMessagePayload,
+  renderTreeseedAgentHelp,
+  resolveAgentHandler,
+  resolveAgentRuntimeProviders,
+  runTreeseedAgentCli,
+  runWorkdayReport,
+  runWorkdayStart,
+  runWorkerCycle,
+  startWorkerLoop
+};

package/dist/agents/adapters/execution.d.ts

@@ -0,0 +1,46 @@
+import type { AgentExecutionAdapter } from '../runtime-types.ts';
+export declare class StubExecutionAdapter implements AgentExecutionAdapter {
+    runTask(input: {
+        prompt: string;
+        runId: string;
+    }): Promise<{
+        status: "completed";
+        summary: string;
+        stdout: string;
+        stderr: string;
+    }>;
+}
+export declare class CopilotExecutionAdapter implements AgentExecutionAdapter {
+    runTask(input: {
+        agent: {
+            cli?: {
+                model?: string;
+                allowTools?: string[];
+                additionalArgs?: string[];
+            };
+        };
+        prompt: string;
+    }): Promise<{
+        status: "completed";
+        summary: string;
+        stdout: string;
+        stderr: string;
+    } | {
+        status: "failed";
+        summary: string;
+        stdout: string;
+        stderr: string;
+    }>;
+}
+export declare class ManualExecutionAdapter implements AgentExecutionAdapter {
+    runTask(input: {
+        prompt: string;
+        runId: string;
+    }): Promise<{
+        status: "completed";
+        summary: string;
+        stdout: string;
+        stderr: string;
+    }>;
+}
+export declare function createExecutionAdapter(): StubExecutionAdapter | CopilotExecutionAdapter | ManualExecutionAdapter;

package/dist/agents/adapters/execution.js

@@ -0,0 +1,90 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { normalizeAgentCliOptions, buildCopilotAllowToolArgs } from "../cli-tools.js";
+import { getTreeseedAgentProviderSelections } from "@treeseed/sdk/platform/deploy-runtime";
+const execFileAsync = promisify(execFile);
+class StubExecutionAdapter {
+  async runTask(input) {
+    return {
+      status: "completed",
+      summary: `Stubbed Copilot execution for ${input.runId}.`,
+      stdout: [
+        "# Planned Task",
+        "",
+        "1. Inspect the requested architecture context.",
+        "2. Produce a safe local change artifact.",
+        "3. Summarize the implementation intent.",
+        "",
+        `Prompt digest: ${input.prompt.slice(0, 240)}`
+      ].join("\n"),
+      stderr: ""
+    };
+  }
+}
+class CopilotExecutionAdapter {
+  async runTask(input) {
+    const cli = normalizeAgentCliOptions(input.agent.cli);
+    const args = ["copilot", "-p", input.prompt];
+    if (cli.model) {
+      args.push("--model", cli.model);
+    }
+    args.push(...buildCopilotAllowToolArgs(cli.allowTools));
+    args.push(...cli.additionalArgs ?? []);
+    try {
+      const { stdout, stderr } = await execFileAsync("gh", args, {
+        cwd: process.cwd(),
+        env: process.env,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      return {
+        status: "completed",
+        summary: "Copilot task completed.",
+        stdout,
+        stderr
+      };
+    } catch (error) {
+      const stderr = error && typeof error === "object" && "stderr" in error ? String(error.stderr ?? "") : error instanceof Error ? error.message : String(error);
+      return {
+        status: "failed",
+        summary: "Copilot task failed.",
+        stdout: "",
+        stderr
+      };
+    }
+  }
+}
+class ManualExecutionAdapter {
+  async runTask(input) {
+    return {
+      status: "completed",
+      summary: `Manual execution mode is enabled for ${input.runId}.`,
+      stdout: [
+        "# Manual Execution Required",
+        "",
+        "This agent run is configured for manual execution.",
+        "Review the prompt below and complete the work outside the automated adapter.",
+        "",
+        input.prompt
+      ].join("\n"),
+      stderr: ""
+    };
+  }
+}
+function createExecutionAdapter() {
+  const configuredMode = String(
+    process.env.TREESEED_AGENT_EXECUTION_PROVIDER ?? getTreeseedAgentProviderSelections().execution
+  ).toLowerCase();
+  if (configuredMode === "manual") {
+    return new ManualExecutionAdapter();
+  }
+  if (configuredMode !== "copilot") {
+    return new StubExecutionAdapter();
+  }
+  return new CopilotExecutionAdapter();
+}
+export {
+  CopilotExecutionAdapter,
+  ManualExecutionAdapter,
+  StubExecutionAdapter,
+  createExecutionAdapter
+};

package/dist/agents/adapters/mutations.d.ts

@@ -0,0 +1,22 @@
+import type { AgentMutationAdapter } from '../runtime-types.ts';
+export declare class LocalBranchMutationAdapter implements AgentMutationAdapter {
+    private readonly git;
+    constructor(repoRoot: string);
+    writeArtifact(input: {
+        runId: string;
+        agent: {
+            execution: {
+                branchPrefix: string;
+            };
+        };
+        relativePath: string;
+        content: string;
+        commitMessage: string;
+    }): Promise<{
+        branchName: string;
+        commitMessage: string;
+        worktreePath: string;
+        commitSha: string;
+        changedPaths: string[];
+    }>;
+}

package/dist/agents/adapters/mutations.js

@@ -0,0 +1,30 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { GitRuntime } from "@treeseed/sdk/git-runtime";
+class LocalBranchMutationAdapter {
+  git;
+  constructor(repoRoot) {
+    this.git = new GitRuntime(
+      repoRoot,
+      process.env.TREESEED_AGENT_DISABLE_GIT === "true"
+    );
+  }
+  async writeArtifact(input) {
+    const branchName = `${input.agent.execution.branchPrefix}/${input.runId}`;
+    const worktreePath = await this.git.ensureWorktree(branchName);
+    const filePath = path.join(worktreePath, input.relativePath);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, input.content, "utf8");
+    const git = await this.git.commitFileChange(filePath, branchName, input.commitMessage);
+    return {
+      branchName: git.branchName,
+      commitMessage: git.commitMessage,
+      worktreePath: git.worktreePath,
+      commitSha: git.commitSha,
+      changedPaths: git.changedPaths
+    };
+  }
+}
+export {
+  LocalBranchMutationAdapter
+};

package/dist/agents/adapters/notification.d.ts

@@ -0,0 +1,11 @@
+import type { AgentNotificationAdapter } from '../runtime-types.ts';
+export declare class StubNotificationAdapter implements AgentNotificationAdapter {
+    deliver(input: {
+        recipients: string[];
+    }): Promise<{
+        status: "completed" | "waiting";
+        summary: string;
+        deliveredCount: number;
+    }>;
+}
+export declare function createNotificationAdapter(): StubNotificationAdapter;

package/dist/agents/adapters/notification.js

@@ -0,0 +1,16 @@
+class StubNotificationAdapter {
+  async deliver(input) {
+    return {
+      status: input.recipients.length ? "completed" : "waiting",
+      summary: input.recipients.length ? `Prepared ${input.recipients.length} notification(s).` : "No recipients available for notification.",
+      deliveredCount: input.recipients.length
+    };
+  }
+}
+function createNotificationAdapter() {
+  return new StubNotificationAdapter();
+}
+export {
+  StubNotificationAdapter,
+  createNotificationAdapter
+};

package/dist/agents/adapters/repository.d.ts

@@ -0,0 +1,23 @@
+import type { AgentRepositoryInspectionAdapter } from '../runtime-types.ts';
+export declare class StubRepositoryInspectionAdapter implements AgentRepositoryInspectionAdapter {
+    inspectBranch(input: {
+        branchName: string | null;
+    }): Promise<{
+        branchName: string;
+        changedPaths: any[];
+        commitSha: any;
+        summary: string;
+    }>;
+}
+export declare class GitRepositoryInspectionAdapter implements AgentRepositoryInspectionAdapter {
+    inspectBranch(input: {
+        repoRoot: string;
+        branchName: string | null;
+    }): Promise<{
+        branchName: string;
+        changedPaths: string[];
+        commitSha: string;
+        summary: string;
+    }>;
+}
+export declare function createRepositoryInspectionAdapter(): StubRepositoryInspectionAdapter | GitRepositoryInspectionAdapter;

package/dist/agents/adapters/repository.js

@@ -0,0 +1,61 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { getTreeseedAgentProviderSelections } from "@treeseed/sdk/platform/deploy-runtime";
+const execFileAsync = promisify(execFile);
+class StubRepositoryInspectionAdapter {
+  async inspectBranch(input) {
+    return {
+      branchName: input.branchName,
+      changedPaths: [],
+      commitSha: null,
+      summary: input.branchName ? `Stub repository inspection for ${input.branchName}.` : "No branch to inspect."
+    };
+  }
+}
+class GitRepositoryInspectionAdapter {
+  async inspectBranch(input) {
+    if (!input.branchName) {
+      return {
+        branchName: null,
+        changedPaths: [],
+        commitSha: null,
+        summary: "No branch to inspect."
+      };
+    }
+    try {
+      const { stdout: changedStdout } = await execFileAsync(
+        "git",
+        ["diff", "--name-only", "HEAD~1..HEAD"],
+        { cwd: input.repoRoot, env: process.env }
+      );
+      const { stdout: shaStdout } = await execFileAsync("git", ["rev-parse", "HEAD"], {
+        cwd: input.repoRoot,
+        env: process.env
+      });
+      const changedPaths = changedStdout.split("\n").map((entry) => entry.trim()).filter(Boolean);
+      return {
+        branchName: input.branchName,
+        changedPaths,
+        commitSha: shaStdout.trim() || null,
+        summary: `Inspected ${changedPaths.length} changed path(s) on ${input.branchName}.`
+      };
+    } catch {
+      return {
+        branchName: input.branchName,
+        changedPaths: [],
+        commitSha: null,
+        summary: `Unable to inspect branch ${input.branchName}.`
+      };
+    }
+  }
+}
+function createRepositoryInspectionAdapter() {
+  return String(
+    process.env.TREESEED_AGENT_REPOSITORY_PROVIDER ?? getTreeseedAgentProviderSelections().repository
+  ).toLowerCase() !== "git" ? new StubRepositoryInspectionAdapter() : new GitRepositoryInspectionAdapter();
+}
+export {
+  GitRepositoryInspectionAdapter,
+  StubRepositoryInspectionAdapter,
+  createRepositoryInspectionAdapter
+};

package/dist/agents/adapters/research.d.ts

@@ -0,0 +1,14 @@
+import type { AgentResearchAdapter } from '../runtime-types.ts';
+export declare class StubResearchAdapter implements AgentResearchAdapter {
+    research(input: {
+        questionId: string;
+        reason: string | null;
+        runId: string;
+    }): Promise<{
+        status: "completed";
+        summary: string;
+        markdown: string;
+        sources: any[];
+    }>;
+}
+export declare function createResearchAdapter(): StubResearchAdapter;

package/dist/agents/adapters/research.js

@@ -0,0 +1,25 @@
+class StubResearchAdapter {
+  async research(input) {
+    return {
+      status: "completed",
+      summary: `Research prepared for ${input.questionId}.`,
+      markdown: [
+        "# Research Summary",
+        "",
+        `Question: ${input.questionId}`,
+        `Reason: ${input.reason ?? "not provided"}`,
+        `Run: ${input.runId}`,
+        "",
+        "This is a stub research summary produced by the runtime adapter."
+      ].join("\n"),
+      sources: []
+    };
+  }
+}
+function createResearchAdapter() {
+  return new StubResearchAdapter();
+}
+export {
+  StubResearchAdapter,
+  createResearchAdapter
+};

package/dist/agents/adapters/verification.d.ts

@@ -0,0 +1,36 @@
+import type { AgentVerificationAdapter } from '../runtime-types.ts';
+export declare class StubVerificationAdapter implements AgentVerificationAdapter {
+    runChecks(input: {
+        commands: string[];
+        runId: string;
+    }): Promise<{
+        status: "completed";
+        summary: string;
+        stdout: string;
+        stderr: string;
+    }>;
+}
+export declare class LocalVerificationAdapter implements AgentVerificationAdapter {
+    runChecks(input: {
+        commands: string[];
+    }): Promise<{
+        status: "waiting";
+        summary: string;
+        stdout: string;
+        stderr: string;
+        errorCategory?: undefined;
+    } | {
+        status: "failed";
+        summary: string;
+        stdout: string;
+        stderr: string;
+        errorCategory: "execution_error";
+    } | {
+        status: "completed";
+        summary: string;
+        stdout: string;
+        stderr: string;
+        errorCategory?: undefined;
+    }>;
+}
+export declare function createVerificationAdapter(): StubVerificationAdapter | LocalVerificationAdapter;

package/dist/agents/adapters/verification.js

@@ -0,0 +1,62 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { getTreeseedAgentProviderSelections } from "@treeseed/sdk/platform/deploy-runtime";
+const execFileAsync = promisify(execFile);
+class StubVerificationAdapter {
+  async runChecks(input) {
+    return {
+      status: "completed",
+      summary: input.commands.length ? `Stub verification completed for ${input.runId}.` : "No verification commands configured.",
+      stdout: input.commands.join("\n"),
+      stderr: ""
+    };
+  }
+}
+class LocalVerificationAdapter {
+  async runChecks(input) {
+    if (!input.commands.length) {
+      return {
+        status: "waiting",
+        summary: "No verification commands configured.",
+        stdout: "",
+        stderr: ""
+      };
+    }
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    for (const command of input.commands) {
+      try {
+        const { stdout, stderr } = await execFileAsync("/bin/bash", ["-lc", command], {
+          env: process.env,
+          maxBuffer: 10 * 1024 * 1024
+        });
+        stdoutChunks.push(stdout);
+        stderrChunks.push(stderr);
+      } catch (error) {
+        return {
+          status: "failed",
+          summary: `Verification command failed: ${command}`,
+          stdout: stdoutChunks.join("\n"),
+          stderr: error && typeof error === "object" && "stderr" in error ? String(error.stderr ?? "") : String(error),
+          errorCategory: "execution_error"
+        };
+      }
+    }
+    return {
+      status: "completed",
+      summary: `Verification completed for ${input.commands.length} command(s).`,
+      stdout: stdoutChunks.join("\n"),
+      stderr: stderrChunks.join("\n")
+    };
+  }
+}
+function createVerificationAdapter() {
+  return String(
+    process.env.TREESEED_AGENT_VERIFICATION_PROVIDER ?? getTreeseedAgentProviderSelections().verification
+  ).toLowerCase() !== "local" ? new StubVerificationAdapter() : new LocalVerificationAdapter();
+}
+export {
+  LocalVerificationAdapter,
+  StubVerificationAdapter,
+  createVerificationAdapter
+};

package/dist/agents/cli-tools.d.ts

@@ -0,0 +1 @@
+export { normalizeAgentCliOptions, buildCopilotAllowToolArgs } from '@treeseed/sdk/cli-tools';