@treeseed/agent 0.8.5

package/dist/services/worker.js

@@ -0,0 +1,436 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AgentKernel } from "../agents/kernel/agent-kernel.js";
+import { createControlPlaneReporter } from "@treeseed/sdk";
+import { buildTaskContext, createQueueClient, createServiceSdk, resolveServiceRepoRoot, resolveWorkerConfig } from "./common.js";
+function parseTaskPayload(task) {
+  const raw = typeof task?.payloadJson === "string" ? task.payloadJson : "{}";
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readCapacityEnvelope(payload) {
+  const envelope = asRecord(payload.capacityEnvelope);
+  return Object.keys(envelope).length > 0 ? envelope : null;
+}
+function runnerRepositoryPath(volumeRoot, repositoryId, taskId) {
+  const repositoryRoot = join(volumeRoot, "repositories", repositoryId);
+  return {
+    repositoryRoot,
+    bareGit: join(repositoryRoot, "bare.git"),
+    worktree: join(repositoryRoot, "worktrees", taskId)
+  };
+}
+function runnerComposedWorkspacePath(volumeRoot, hubId) {
+  const workspaceRoot = join(volumeRoot, "workspaces", hubId);
+  return {
+    root: workspaceRoot,
+    parent: join(workspaceRoot, "workspace-root"),
+    site: join(workspaceRoot, "site"),
+    content: join(workspaceRoot, "content"),
+    manifest: join(workspaceRoot, ".treeseed", "workspace.json")
+  };
+}
+async function ensureRunnerComposedWorkspace(volumeRoot, task) {
+  const payload = parseTaskPayload(task);
+  const workspace = asRecord(payload.workspace);
+  const hubId = String(workspace.hubId ?? payload.projectId ?? task.projectId ?? "").trim();
+  if (!hubId) return null;
+  const paths = runnerComposedWorkspacePath(volumeRoot, hubId);
+  await mkdir(paths.parent, { recursive: true });
+  await mkdir(paths.site, { recursive: true });
+  await mkdir(paths.content, { recursive: true });
+  await mkdir(join(paths.root, ".treeseed"), { recursive: true });
+  await writeFile(paths.manifest, `${JSON.stringify({
+    schemaVersion: 1,
+    kind: "treeseed_composed_workspace",
+    hubId,
+    softwareRepository: workspace.softwareRepository ?? null,
+    contentRepository: workspace.contentRepository ?? null,
+    parentRepository: workspace.parentRepository ?? null,
+    paths: {
+      workspaceRoot: paths.parent,
+      site: paths.site,
+      content: paths.content
+    },
+    allowedWriteTargets: Array.isArray(workspace.allowedWriteTargets) ? workspace.allowedWriteTargets : ["content"],
+    credentialSessionScopes: workspace.credentialSessionScopes ?? {
+      software: ["repository:software"],
+      content: ["repository:content"],
+      parentWorkspace: []
+    },
+    credentialScopes: workspace.credentialScopes ?? {
+      software: ["repository:software"],
+      content: ["repository:content"],
+      parentWorkspace: []
+    },
+    contentOverlay: workspace.contentOverlay ?? "src_content_when_present"
+  }, null, 2)}
+`, "utf8");
+  return paths;
+}
+class WorkerPausedForApproval extends Error {
+  constructor(request) {
+    super(String(request.summary ?? request.title ?? "Task paused for approval."));
+    this.request = request;
+  }
+  request;
+}
+async function executeQueuedTask(options) {
+  const context = await buildTaskContext(options.sdk, options.taskId);
+  const task = context.task;
+  const payload = parseTaskPayload(task);
+  await ensureRunnerComposedWorkspace(options.volumeRoot, {
+    ...task ?? {},
+    payloadJson: JSON.stringify(payload)
+  });
+  const capacityEnvelope = readCapacityEnvelope(payload);
+  const explicitApproval = asRecord(payload.approvalRequest);
+  if (Object.keys(explicitApproval).length > 0 || capacityEnvelope?.maxCredits === 0) {
+    throw new WorkerPausedForApproval({
+      kind: String(explicitApproval.kind ?? "capacity_boundary"),
+      title: String(explicitApproval.title ?? "Task paused for approval"),
+      summary: String(explicitApproval.summary ?? "The task reached a boundary outside its approved execution envelope."),
+      severity: explicitApproval.severity ?? "medium",
+      workDayId: task?.workDayId ?? task?.work_day_id ?? null,
+      taskId: options.taskId,
+      options: Array.isArray(explicitApproval.options) ? explicitApproval.options : [],
+      recommendation: asRecord(explicitApproval.recommendation),
+      policySnapshot: {
+        capacityEnvelope,
+        ...asRecord(explicitApproval.policySnapshot)
+      }
+    });
+  }
+  const executionKind = typeof payload.executionKind === "string" ? payload.executionKind : null;
+  if (String(task?.type ?? task?.taskType ?? "") === "refresh_project_graph") {
+    const config = resolveWorkerConfig();
+    const projectId = typeof payload.projectId === "string" ? payload.projectId : config.projectId;
+    const repositoryId = typeof payload.repositoryId === "string" ? payload.repositoryId : projectId;
+    const paths = runnerRepositoryPath(config.volumeRoot, repositoryId, options.taskId);
+    await mkdir(paths.bareGit, { recursive: true });
+    await mkdir(paths.worktree, { recursive: true });
+    const graphRefresh = await options.sdk.refreshGraph();
+    const graphVersion = graphRefresh.snapshotRoot;
+    await options.sdk.create({
+      model: "graph_run",
+      data: {
+        id: `${options.taskId}:graph`,
+        workDayId: String(task?.workDayId ?? task?.work_day_id ?? ""),
+        corpusHash: graphVersion,
+        graphVersion,
+        statsJson: JSON.stringify(graphRefresh),
+        snapshotRef: graphVersion
+      },
+      actor: "worker"
+    });
+    if (typeof options.sdk.updateWorkDayGraph === "function") {
+      await options.sdk.updateWorkDayGraph({
+        id: String(task?.workDayId ?? task?.work_day_id ?? ""),
+        graphVersion,
+        summaryPatch: {
+          graphRefresh: {
+            state: "completed",
+            graphVersion,
+            snapshotRef: graphVersion,
+            runnerId: config.workerId
+          }
+        }
+      });
+    }
+    if (typeof options.sdk.recordRepositoryClaim === "function") {
+      await options.sdk.recordRepositoryClaim({
+        projectId,
+        repositoryId,
+        runnerId: config.workerId,
+        runnerServiceName: config.runnerServiceName,
+        volumeIdentity: config.volumeIdentity,
+        lastSeenCommit: typeof payload.commitSha === "string" ? payload.commitSha : null,
+        metadata: {
+          bareGit: paths.bareGit,
+          worktree: paths.worktree
+        }
+      });
+    }
+    return {
+      workerId: options.workerId,
+      queueAttempt: options.queueAttempt,
+      graphVersion,
+      snapshotRef: graphVersion,
+      repositoryId,
+      paths,
+      summary: {
+        status: "completed",
+        workerId: options.workerId,
+        summary: `Refreshed project graph ${graphVersion}`
+      }
+    };
+  }
+  if (executionKind === "workflow_dispatch" || executionKind === "sdk_dispatch") {
+    const namespace = typeof payload.namespace === "string" ? payload.namespace : "workflow";
+    const operation = typeof payload.operation === "string" ? payload.operation : "";
+    if (!operation) {
+      throw new Error(`Task ${options.taskId} does not define a dispatch operation.`);
+    }
+    const input = payload.input && typeof payload.input === "object" ? payload.input : {};
+    const result = await options.sdk.dispatch({
+      namespace,
+      operation,
+      input,
+      preferredMode: "prefer_local"
+    });
+    return {
+      workerId: options.workerId,
+      queueAttempt: options.queueAttempt,
+      executionKind,
+      namespace,
+      operation,
+      result,
+      summary: {
+        status: "completed",
+        workerId: options.workerId,
+        summary: `Executed ${namespace}:${operation}`
+      }
+    };
+  }
+  const agentSlug = typeof payload.agentSlug === "string" && payload.agentSlug ? payload.agentSlug : typeof context.agent?.slug === "string" && context.agent.slug ? context.agent.slug : typeof task?.agentId === "string" && task.agentId ? task.agentId : typeof task?.agent_id === "string" && task.agent_id ? task.agent_id : "";
+  if (!agentSlug) {
+    throw new Error(`Task ${options.taskId} does not resolve to an agent slug.`);
+  }
+  const invocation = payload.invocation && typeof payload.invocation === "object" ? payload.invocation : null;
+  const agentResult = await options.kernel.runAgent(agentSlug, invocation ? "manual" : "auto", invocation);
+  return {
+    workerId: options.workerId,
+    queueAttempt: options.queueAttempt,
+    agentSlug,
+    result: agentResult,
+    summary: {
+      status: agentResult.status,
+      workerId: options.workerId,
+      summary: agentResult.summary
+    },
+    capacityUsage: capacityEnvelope?.providerId && capacityEnvelope?.laneId ? {
+      capacityProviderId: capacityEnvelope.providerId,
+      laneId: capacityEnvelope.laneId,
+      reservationId: capacityEnvelope.reservationIds?.[0] ?? null,
+      credits: Number(payload.estimatedCredits ?? capacityEnvelope.maxCredits ?? 1),
+      source: "worker"
+    } : null
+  };
+}
+async function runWorkerCycle() {
+  const sdk = createServiceSdk();
+  const queue = createQueueClient();
+  const config = resolveWorkerConfig();
+  const kernel = new AgentKernel(sdk, resolveServiceRepoRoot());
+  if (typeof sdk.recordWorkerRunner === "function") {
+    await sdk.recordWorkerRunner({
+      projectId: config.projectId,
+      environment: config.environment,
+      runnerId: config.workerId,
+      runnerServiceName: config.runnerServiceName,
+      volumeIdentity: config.volumeIdentity,
+      state: "active",
+      maxLocalWorkers: config.maxLocalWorkers,
+      activeLocalWorkers: 0,
+      metadata: {
+        volumeRoot: config.volumeRoot
+      }
+    }).catch(() => null);
+  }
+  if (!queue) {
+    if (process.env.TREESEED_LOCAL_DEV_MODE?.trim()) {
+      return { ok: true, processed: 0, idle: true, reason: "queue_unconfigured" };
+    }
+    throw new Error("Worker requires CLOUDFLARE_ACCOUNT_ID, TREESEED_QUEUE_ID, and TREESEED_QUEUE_PULL_TOKEN.");
+  }
+  const pulled = await queue.pull({
+    batchSize: config.batchSize,
+    visibilityTimeoutMs: config.visibilityTimeoutMs
+  });
+  if (pulled.messages.length === 0) {
+    return { ok: true, processed: 0 };
+  }
+  const maxLocalWorkers = Number.isFinite(Number(config.maxLocalWorkers)) ? Math.max(1, Number(config.maxLocalWorkers)) : 1;
+  const selectedMessages = pulled.messages.slice(0, maxLocalWorkers);
+  const results = await Promise.all(selectedMessages.map(async (message) => {
+    try {
+      await sdk.claimTask({
+        id: message.body.taskId,
+        workerId: config.workerId,
+        leaseSeconds: config.leaseSeconds,
+        actor: "worker"
+      });
+      await sdk.recordTaskProgress({
+        id: message.body.taskId,
+        workerId: config.workerId,
+        state: "running",
+        appendEvent: {
+          kind: "worker_started",
+          data: { workerId: config.workerId, queueAttempt: message.attempts }
+        },
+        actor: "worker"
+      });
+      let output;
+      try {
+        output = await executeQueuedTask({
+          sdk,
+          kernel,
+          taskId: message.body.taskId,
+          workerId: config.workerId,
+          queueAttempt: message.attempts,
+          volumeRoot: config.volumeRoot
+        });
+      } catch (error) {
+        if (error instanceof WorkerPausedForApproval) {
+          const reporter = createControlPlaneReporter();
+          const context = await buildTaskContext(sdk, message.body.taskId);
+          const task = context.task;
+          const projectId = String(process.env.TREESEED_PROJECT_ID ?? "");
+          await reporter.createApprovalRequest({
+            projectId,
+            teamId: String(error.request.teamId ?? process.env.TREESEED_TEAM_ID ?? ""),
+            workDayId: typeof error.request.workDayId === "string" ? error.request.workDayId : String(task?.workDayId ?? task?.work_day_id ?? ""),
+            taskId: message.body.taskId,
+            kind: String(error.request.kind ?? "capacity_boundary"),
+            severity: error.request.severity === "high" || error.request.severity === "low" ? error.request.severity : "medium",
+            requestedByType: "worker",
+            requestedById: config.workerId,
+            title: String(error.request.title ?? "Task paused for approval"),
+            summary: String(error.request.summary ?? error.message),
+            options: Array.isArray(error.request.options) ? error.request.options : [],
+            recommendation: asRecord(error.request.recommendation),
+            policySnapshot: asRecord(error.request.policySnapshot)
+          }).catch(() => null);
+          await sdk.recordTaskProgress({
+            id: message.body.taskId,
+            workerId: config.workerId,
+            state: "paused_for_approval",
+            appendEvent: {
+              kind: "paused_for_approval",
+              data: error.request
+            },
+            actor: "worker"
+          });
+          await queue.ack([message.leaseId]);
+          return 1;
+        }
+        throw error;
+      }
+      await sdk.completeTask({
+        id: message.body.taskId,
+        output,
+        summary: output.summary,
+        actor: "worker"
+      });
+      if (output.capacityUsage?.capacityProviderId && output.capacityUsage?.laneId) {
+        const reporter = createControlPlaneReporter();
+        await reporter.reportCapacityUsage({
+          capacityProviderId: output.capacityUsage.capacityProviderId,
+          laneId: output.capacityUsage.laneId,
+          reservationId: output.capacityUsage.reservationId,
+          teamId: String(process.env.TREESEED_TEAM_ID ?? ""),
+          projectId: String(process.env.TREESEED_PROJECT_ID ?? ""),
+          workDayId: message.body.workDayId,
+          taskId: message.body.taskId,
+          phase: "consume",
+          credits: output.capacityUsage.credits,
+          source: "worker",
+          metadata: {
+            workerId: config.workerId,
+            queueAttempt: message.attempts
+          }
+        }).catch(() => null);
+      }
+      await queue.ack([message.leaseId]);
+      return 1;
+    } catch (error) {
+      const retryDelaySeconds = Math.min(300, Math.max(15, message.attempts * 30));
+      await sdk.failTask({
+        id: message.body.taskId,
+        errorMessage: error instanceof Error ? error.message : String(error),
+        retryable: true,
+        nextVisibleAt: new Date(Date.now() + retryDelaySeconds * 1e3).toISOString(),
+        actor: "worker"
+      }).catch(() => null);
+      await queue.retry([{ leaseId: message.leaseId, delaySeconds: retryDelaySeconds }]);
+      return 0;
+    }
+  }));
+  return { ok: true, processed: results.reduce((sum, value) => sum + value, 0) };
+}
+function shouldExitWorkerLoopAfterIdle(options) {
+  const idleExitMs = Number(options.idleExitMs ?? 0);
+  if (!Number.isFinite(idleExitMs) || idleExitMs <= 0) {
+    return false;
+  }
+  if (options.processed > 0 || options.idleSince === null) {
+    return false;
+  }
+  return options.now - options.idleSince >= idleExitMs;
+}
+async function recordWorkerLoopExitState(config) {
+  const sdk = createServiceSdk();
+  if (typeof sdk.recordWorkerRunner !== "function") {
+    return;
+  }
+  await sdk.recordWorkerRunner({
+    projectId: config.projectId,
+    environment: config.environment,
+    runnerId: config.workerId,
+    runnerServiceName: config.runnerServiceName,
+    volumeIdentity: config.volumeIdentity,
+    state: "sleeping",
+    maxLocalWorkers: config.maxLocalWorkers,
+    activeLocalWorkers: 0,
+    metadata: {
+      volumeRoot: config.volumeRoot,
+      reason: "idle_exit"
+    }
+  }).catch(() => null);
+}
+async function startWorkerLoop() {
+  const config = resolveWorkerConfig();
+  let idleSince = null;
+  for (; ; ) {
+    try {
+      const result = await runWorkerCycle();
+      const processed = Number(result.processed ?? 0);
+      if (processed > 0) {
+        idleSince = null;
+      } else {
+        idleSince ??= Date.now();
+        if (shouldExitWorkerLoopAfterIdle({
+          idleExitMs: config.idleExitMs,
+          idleSince,
+          now: Date.now(),
+          processed
+        })) {
+          await recordWorkerLoopExitState(config);
+          return;
+        }
+      }
+    } catch (error) {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, config.pollIntervalMs));
+  }
+}
+const currentFile = fileURLToPath(import.meta.url);
+const entryFile = process.argv[1] ?? "";
+if (entryFile === currentFile) {
+  await startWorkerLoop();
+}
+export {
+  runWorkerCycle,
+  shouldExitWorkerLoopAfterIdle,
+  startWorkerLoop
+};

package/dist/templates/github/deploy-processing.workflow.yml

@@ -0,0 +1,119 @@
+name: Treeseed Processing Deploy
+
+on:
+  workflow_call:
+    inputs:
+      environment:
+        required: true
+        type: string
+      action_kind:
+        required: true
+        type: string
+      project_id:
+        required: false
+        type: string
+      preview_id:
+        required: false
+        type: string
+  workflow_dispatch:
+    inputs:
+      environment:
+        required: true
+        default: staging
+        type: choice
+        options:
+          - staging
+          - prod
+      action_kind:
+        required: true
+        default: deploy_processing
+        type: choice
+        options:
+          - deploy_processing
+          - monitor
+      project_id:
+        required: false
+        type: string
+      preview_id:
+        required: false
+        type: string
+
+jobs:
+  processing:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    environment: ${{ inputs.environment == 'prod' && 'production' || 'staging' }}
+    env:
+      TREESEED_BOOTSTRAP_MODE: auto
+      CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+      CLOUDFLARE_ACCOUNT_ID: ${{ vars.CLOUDFLARE_ACCOUNT_ID }}
+      RAILWAY_API_TOKEN: ${{ secrets.RAILWAY_API_TOKEN }}
+      RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}
+      TREESEED_RAILWAY_WORKSPACE: ${{ vars.TREESEED_RAILWAY_WORKSPACE }}
+      TREESEED_API_BASE_URL: ${{ vars.TREESEED_API_BASE_URL }}
+      TREESEED_API_AUTH_SECRET: ${{ secrets.TREESEED_API_AUTH_SECRET }}
+      TREESEED_API_D1_DATABASE_ID: ${{ vars.TREESEED_API_D1_DATABASE_ID }}
+      TREESEED_API_WEB_SERVICE_ID: ${{ vars.TREESEED_API_WEB_SERVICE_ID }}
+      TREESEED_API_WEB_SERVICE_SECRET: ${{ secrets.TREESEED_API_WEB_SERVICE_SECRET }}
+      TREESEED_API_WEB_ASSERTION_SECRET: ${{ secrets.TREESEED_API_WEB_ASSERTION_SECRET }}
+      TREESEED_API_BOOTSTRAP_ADMIN_ALLOWLIST: ${{ vars.TREESEED_API_BOOTSTRAP_ADMIN_ALLOWLIST }}
+      TREESEED_PROJECT_ID: ${{ inputs.project_id || vars.TREESEED_PROJECT_ID }}
+      TREESEED_PROJECT_RUNNER_TOKEN: ${{ secrets.TREESEED_PROJECT_RUNNER_TOKEN }}
+      TREESEED_WORKER_POOL_SCALER: ${{ vars.TREESEED_WORKER_POOL_SCALER }}
+      TREESEED_AGENT_POOL_MIN_WORKERS: ${{ vars.TREESEED_AGENT_POOL_MIN_WORKERS }}
+      TREESEED_AGENT_POOL_MAX_WORKERS: ${{ vars.TREESEED_AGENT_POOL_MAX_WORKERS }}
+      TREESEED_AGENT_POOL_TARGET_QUEUE_DEPTH: ${{ vars.TREESEED_AGENT_POOL_TARGET_QUEUE_DEPTH }}
+      TREESEED_AGENT_POOL_COOLDOWN_SECONDS: ${{ vars.TREESEED_AGENT_POOL_COOLDOWN_SECONDS }}
+      TREESEED_WORKDAY_TIMEZONE: ${{ vars.TREESEED_WORKDAY_TIMEZONE }}
+      TREESEED_WORKDAY_WINDOWS_JSON: ${{ vars.TREESEED_WORKDAY_WINDOWS_JSON }}
+      TREESEED_WORKDAY_TASK_CREDIT_BUDGET: ${{ vars.TREESEED_WORKDAY_TASK_CREDIT_BUDGET }}
+      TREESEED_MANAGER_MAX_QUEUED_TASKS: ${{ vars.TREESEED_MANAGER_MAX_QUEUED_TASKS }}
+      TREESEED_MANAGER_MAX_QUEUED_CREDITS: ${{ vars.TREESEED_MANAGER_MAX_QUEUED_CREDITS }}
+      TREESEED_MANAGER_PRIORITY_MODELS: ${{ vars.TREESEED_MANAGER_PRIORITY_MODELS }}
+      TREESEED_TASK_CREDIT_WEIGHTS_JSON: ${{ vars.TREESEED_TASK_CREDIT_WEIGHTS_JSON }}
+      TREESEED_RAILWAY_PROJECT_ID: ${{ vars.TREESEED_RAILWAY_PROJECT_ID }}
+      TREESEED_RAILWAY_ENVIRONMENT_ID: ${{ vars.TREESEED_RAILWAY_ENVIRONMENT_ID }}
+      TREESEED_RAILWAY_WORKER_SERVICE_ID: ${{ vars.TREESEED_RAILWAY_WORKER_SERVICE_ID }}
+      TREESEED_CAPACITY_PROVIDER_ID: ${{ vars.TREESEED_CAPACITY_PROVIDER_ID }}
+      TREESEED_CAPACITY_PROVIDER_TEAM_ID: ${{ vars.TREESEED_CAPACITY_PROVIDER_TEAM_ID }}
+      TREESEED_CAPACITY_PROVIDER_SERVICE_BASE_URL: ${{ vars.TREESEED_CAPACITY_PROVIDER_SERVICE_BASE_URL }}
+      TREESEED_PROCESSING_DRAIN: ${{ vars.TREESEED_PROCESSING_DRAIN }}
+      TREESEED_WORKFLOW_ACTION: ${{ inputs.action_kind }}
+      TREESEED_WORKFLOW_ENVIRONMENT: ${{ inputs.environment }}
+      TREESEED_WORKFLOW_PROJECT: ${{ inputs.project_id || vars.TREESEED_PROJECT_ID }}
+      TREESEED_WORKFLOW_PREVIEW_ID: ${{ inputs.preview_id }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+          cache-dependency-path: package-lock.json
+
+      - name: Install dependencies
+        shell: bash
+        run: |
+          set -euo pipefail
+          node -e "const fs = require('fs'); for (const file of ['packages/sdk/package.json', 'packages/agent/package.json', 'packages/core/package.json', 'packages/cli/package.json']) { if (!fs.existsSync(file)) continue; const p = JSON.parse(fs.readFileSync(file, 'utf8')); if (p.scripts) delete p.scripts.prepare; fs.writeFileSync(file, JSON.stringify(p, null, '\t') + '\n'); }"
+          npm ci --ignore-scripts
+
+      - name: Build package artifacts
+        shell: bash
+        run: |
+          set -euo pipefail
+          for dir in packages/sdk packages/agent packages/core packages/cli; do
+            if test -f "${dir}/package.json"; then npm --prefix "${dir}" run build:dist; fi
+          done
+
+      - name: Run processing workflow action
+        shell: bash
+        run: |
+          set -euo pipefail
+          EXTRA_ARGS=()
+          if [[ -n "${TREESEED_WORKFLOW_PROJECT:-}" ]]; then EXTRA_ARGS+=(--project-id "${TREESEED_WORKFLOW_PROJECT}"); fi
+          if [[ -n "${TREESEED_WORKFLOW_PREVIEW_ID:-}" ]]; then EXTRA_ARGS+=(--preview-id "${TREESEED_WORKFLOW_PREVIEW_ID}"); fi
+          node ./packages/sdk/scripts/run-ts.mjs ./packages/sdk/scripts/tenant-workflow-action.ts --action "${TREESEED_WORKFLOW_ACTION}" --environment "${TREESEED_WORKFLOW_ENVIRONMENT}" "${EXTRA_ARGS[@]}"

package/package.json

@@ -0,0 +1,136 @@
+{
+  "name": "@treeseed/agent",
+  "version": "0.8.5",
+  "description": "Treeseed agent service runtime package.",
+  "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/treeseed-ai/agent.git",
+    "directory": "."
+  },
+  "homepage": "https://treeseed.ai",
+  "bugs": {
+    "url": "https://github.com/treeseed-ai/agent/issues"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./api": {
+      "types": "./dist/api/index.d.ts",
+      "default": "./dist/api/index.js"
+    },
+    "./api/app": {
+      "types": "./dist/api/app.d.ts",
+      "default": "./dist/api/app.js"
+    },
+    "./api/auth/d1-provider": {
+      "types": "./dist/api/auth/d1-provider.d.ts",
+      "default": "./dist/api/auth/d1-provider.js"
+    },
+    "./services/worker": {
+      "types": "./dist/services/worker.d.ts",
+      "default": "./dist/services/worker.js"
+    },
+    "./services/manager": {
+      "types": "./dist/services/manager.d.ts",
+      "default": "./dist/services/manager.js"
+    },
+    "./services/agents": {
+      "types": "./dist/services/agents.d.ts",
+      "default": "./dist/services/agents.js"
+    },
+    "./services/remote-runner": {
+      "types": "./dist/services/remote-runner.d.ts",
+      "default": "./dist/services/remote-runner.js"
+    },
+    "./services/workday-manager": {
+      "types": "./dist/services/workday-manager.d.ts",
+      "default": "./dist/services/workday-manager.js"
+    },
+    "./services/workday-start": {
+      "types": "./dist/services/workday-start.d.ts",
+      "default": "./dist/services/workday-start.js"
+    },
+    "./services/workday-report": {
+      "types": "./dist/services/workday-report.d.ts",
+      "default": "./dist/services/workday-report.js"
+    },
+    "./runtime-types": {
+      "types": "./dist/agents/runtime-types.d.ts",
+      "default": "./dist/agents/runtime-types.js"
+    },
+    "./cli": {
+      "types": "./dist/agents/cli.d.ts",
+      "default": "./dist/agents/cli.js"
+    },
+    "./contracts/messages": {
+      "types": "./dist/agents/contracts/messages.d.ts",
+      "default": "./dist/agents/contracts/messages.js"
+    },
+    "./contracts/run": {
+      "types": "./dist/agents/contracts/run.d.ts",
+      "default": "./dist/agents/contracts/run.js"
+    }
+  },
+  "files": [
+    "README.md",
+    "dist",
+    "Dockerfile",
+    "templates"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "setup": "npm install",
+    "setup:ci": "npm ci",
+    "build": "npm run build:dist",
+    "build:dist": "node ./scripts/run-ts.mjs ./scripts/build-dist.ts",
+    "dev:manager": "node ./scripts/run-ts.mjs ./src/services/manager.ts",
+    "dev:worker": "node ./scripts/run-ts.mjs ./src/services/worker.ts",
+    "dev:workday-start": "node ./scripts/run-ts.mjs ./src/services/workday-start.ts",
+    "dev:workday-report": "node ./scripts/run-ts.mjs ./src/services/workday-report.ts",
+    "dev:remote-runner": "node ./scripts/run-ts.mjs ./src/services/remote-runner.ts",
+    "start:manager": "node ./dist/services/manager.js",
+    "start:worker": "node ./dist/services/worker.js",
+    "start:workday-start": "node ./dist/services/workday-start.js",
+    "start:workday-report": "node ./dist/services/workday-report.js",
+    "start:local-manager-cloudflare": "bash ./scripts/run-local-manager-cloudflare.sh",
+    "lint": "npm run build:dist",
+    "test": "npm run test:unit && npm run test:smoke",
+    "test:unit": "vitest run --config ./vitest.config.ts",
+    "prepack": "npm run build:dist",
+    "test:smoke": "node ./scripts/run-ts.mjs ./scripts/test-smoke.ts",
+    "verify:direct": "npm run release:verify",
+    "verify:local": "node --input-type=module -e \"process.env.TREESEED_VERIFY_DRIVER='direct'; await import('@treeseed/sdk/scripts/verify-driver')\"",
+    "verify:action": "node --input-type=module -e \"process.env.TREESEED_VERIFY_DRIVER='act'; await import('@treeseed/sdk/scripts/verify-driver')\"",
+    "verify": "node --input-type=module -e \"await import('@treeseed/sdk/scripts/verify-driver')\"",
+    "release:setup": "npm run setup:ci",
+    "release:check-tag": "node ./scripts/run-ts.mjs ./scripts/assert-release-tag-version.ts",
+    "release:verify": "node ./scripts/run-ts.mjs ./scripts/release-verify.ts",
+    "release:publish": "node ./scripts/run-ts.mjs ./scripts/publish-package.ts"
+  },
+  "dependencies": {
+    "@treeseed/sdk": "0.8.5",
+    "esbuild": "0.28.0",
+    "hono": "^4.8.2",
+    "typescript": "^5.9.3",
+    "yaml": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "vitest": "^4.1.2"
+  },
+  "bin": {
+    "treeseed-agents": "dist/scripts/treeseed-agents.js",
+    "treeseed-agent-api": "dist/scripts/treeseed-agent-api.js",
+    "treeseed-agent-service": "dist/scripts/treeseed-agent-service.js"
+  }
+}