@treeseed/agent 0.8.5

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+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 { createTreeseedApiApp, createTreeseedApiRouter, createTreeseedNodeServer, createRailwayTreeseedApiServer, resolveApiConfig, resolveApiRuntimeProviders, } from './api/index.ts';
+export { createManagerApp } from './services/manager.ts';
+export { runScheduledWorkdayManager } from './services/workday-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';
+export type * from './api/types.ts';

package/dist/index.js

@@ -0,0 +1,41 @@
+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 {
+  createTreeseedApiApp,
+  createTreeseedApiRouter,
+  createTreeseedNodeServer,
+  createRailwayTreeseedApiServer,
+  resolveApiConfig,
+  resolveApiRuntimeProviders
+} from "./api/index.js";
+import { createManagerApp } from "./services/manager.js";
+import { runScheduledWorkdayManager } from "./services/workday-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,
+  createRailwayTreeseedApiServer,
+  createTreeseedApiApp,
+  createTreeseedApiRouter,
+  createTreeseedNodeServer,
+  listRegisteredAgentHandlers,
+  listTreeseedAgentCommands,
+  parseAgentMessagePayload,
+  renderTreeseedAgentHelp,
+  resolveAgentHandler,
+  resolveAgentRuntimeProviders,
+  resolveApiConfig,
+  resolveApiRuntimeProviders,
+  runScheduledWorkdayManager,
+  runTreeseedAgentCli,
+  runWorkdayReport,
+  runWorkdayStart,
+  runWorkerCycle,
+  startWorkerLoop
+};

package/dist/scripts/assert-release-tag-version.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/assert-release-tag-version.js

@@ -0,0 +1,20 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const packageJson = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'));
+const packageVersion = packageJson.version;
+const tagName = process.argv[2] || process.env.GITHUB_REF_NAME;
+if (!tagName) {
+    console.error('Release tag validation requires a tag name argument or GITHUB_REF_NAME.');
+    process.exit(1);
+}
+if (!/^\d+\.\d+\.\d+$/.test(tagName)) {
+    console.error(`Release tag "${tagName}" must be a plain semver tag like "${packageVersion}".`);
+    process.exit(1);
+}
+if (tagName !== packageVersion) {
+    console.error(`Release tag "${tagName}" does not match @treeseed/agent version "${packageVersion}".`);
+    process.exit(1);
+}
+console.log(`Release tag "${tagName}" matches @treeseed/agent version "${packageVersion}".`);

package/dist/scripts/build-dist.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/build-dist.js

@@ -0,0 +1,106 @@
+import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, chmodSync } from 'node:fs';
+import { dirname, extname, join, relative, resolve } from 'node:path';
+import { build } from 'esbuild';
+import ts from 'typescript';
+import { packageRoot } from './package-tools.js';
+const srcRoot = resolve(packageRoot, 'src');
+const scriptsRoot = resolve(packageRoot, 'scripts');
+const templatesRoot = resolve(packageRoot, 'templates');
+const distRoot = resolve(packageRoot, 'dist');
+const COPY_EXTENSIONS = new Set(['.d.js', '.json', '.md', '.yaml', '.yml']);
+function walkFiles(root) {
+    const files = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const fullPath = join(root, entry.name);
+        if (entry.isDirectory())
+            files.push(...walkFiles(fullPath));
+        else
+            files.push(fullPath);
+    }
+    return files;
+}
+function ensureDir(filePath) {
+    mkdirSync(dirname(filePath), { recursive: true });
+}
+function rewriteRuntimeSpecifiers(contents) {
+    return contents
+        .replace(/(['"`])(\.[^'"`\n]+)\.(mjs|ts)\1/g, '$1$2.js$1')
+        .replace(/(['"`])\.\.\/src\//g, '$1../');
+}
+async function compileModule(filePath, sourceRoot, outputRoot) {
+    const relativePath = relative(sourceRoot, filePath);
+    const outputFile = resolve(outputRoot, relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    ensureDir(outputFile);
+    await build({
+        entryPoints: [filePath],
+        outfile: outputFile,
+        platform: 'node',
+        format: 'esm',
+        bundle: false,
+        logLevel: 'silent',
+    });
+    const builtSource = readFileSync(outputFile, 'utf8');
+    writeFileSync(outputFile, rewriteRuntimeSpecifiers(builtSource), 'utf8');
+}
+function copyAsset(filePath, sourceRoot, outputRoot) {
+    const outputFile = resolve(outputRoot, relative(sourceRoot, filePath));
+    ensureDir(outputFile);
+    copyFileSync(filePath, outputFile);
+    if (outputFile.endsWith('.d.js')) {
+        writeFileSync(outputFile, rewriteRuntimeSpecifiers(readFileSync(outputFile, 'utf8')), 'utf8');
+    }
+}
+function transpileScript(filePath) {
+    const source = readFileSync(filePath, 'utf8');
+    const relativePath = relative(scriptsRoot, filePath);
+    const outputFile = resolve(distRoot, 'scripts', relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    const transformed = extname(filePath) === '.ts'
+        ? ts.transpileModule(source, {
+            compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2022 },
+        }).outputText
+        : source;
+    ensureDir(outputFile);
+    writeFileSync(outputFile, rewriteRuntimeSpecifiers(transformed), 'utf8');
+    chmodSync(outputFile, 0o755);
+}
+function emitDeclarations() {
+    const configPath = ts.findConfigFile(packageRoot, ts.sys.fileExists, 'tsconfig.json');
+    if (!configPath)
+        throw new Error('Unable to locate tsconfig.json for declaration build.');
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageRoot);
+    const program = ts.createProgram({
+        rootNames: parsed.fileNames,
+        options: { ...parsed.options, declaration: true, emitDeclarationOnly: true, declarationDir: distRoot, noEmit: false },
+    });
+    const result = program.emit();
+    if (result.emitSkipped)
+        throw new Error('Declaration build failed.');
+}
+rmSync(distRoot, { recursive: true, force: true });
+for (const filePath of walkFiles(srcRoot)) {
+    const extension = extname(filePath);
+    if (extension === '.ts')
+        await compileModule(filePath, srcRoot, distRoot);
+    else if (COPY_EXTENSIONS.has(extension))
+        copyAsset(filePath, srcRoot, distRoot);
+}
+for (const filePath of walkFiles(scriptsRoot)) {
+    const extension = extname(filePath);
+    if (extension === '.ts' || extension === '.ts')
+        transpileScript(filePath);
+}
+emitDeclarations();
+if (existsSync(resolve(distRoot, 'src'))) {
+    cpSync(resolve(distRoot, 'src'), distRoot, { recursive: true });
+    rmSync(resolve(distRoot, 'src'), { recursive: true, force: true });
+}
+if (existsSync(resolve(packageRoot, 'README.md'))) {
+    copyFileSync(resolve(packageRoot, 'README.md'), resolve(distRoot, '..', 'README.md'));
+}
+if (existsSync(resolve(packageRoot, 'Dockerfile'))) {
+    copyFileSync(resolve(packageRoot, 'Dockerfile'), resolve(distRoot, '..', 'Dockerfile'));
+}
+if (existsSync(templatesRoot)) {
+    cpSync(templatesRoot, resolve(distRoot, 'templates'), { recursive: true });
+}

package/dist/scripts/package-tools.d.ts

@@ -0,0 +1 @@
+export declare const packageRoot: string;

package/dist/scripts/package-tools.js

@@ -0,0 +1,7 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const scriptRoot = dirname(fileURLToPath(import.meta.url));
+const packageCandidate = resolve(scriptRoot, '..');
+export const packageRoot = packageCandidate.endsWith('/dist')
+    ? resolve(packageCandidate, '..')
+    : packageCandidate;

package/dist/scripts/publish-package.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/publish-package.js

@@ -0,0 +1,24 @@
+import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const extraArgs = process.argv.slice(2);
+const tagName = process.env.GITHUB_REF_NAME;
+if (tagName && !/^\d+\.\d+\.\d+$/.test(tagName)) {
+    console.error(`Refusing to publish @treeseed/agent from non-stable tag "${tagName}".`);
+    process.exit(1);
+}
+const npmArgs = ['publish', '.', '--access', 'public'];
+if (process.env.GITHUB_ACTIONS === 'true')
+    npmArgs.push('--provenance');
+npmArgs.push(...extraArgs);
+const result = spawnSync('npm', npmArgs, {
+    cwd: packageRoot,
+    stdio: 'inherit',
+    env: process.env,
+});
+if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+}
+process.exit(result.status ?? 1);

package/dist/scripts/release-verify.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/release-verify.js

@@ -0,0 +1,152 @@
+import { cpSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync, existsSync } from 'node:fs';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, extname, join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { packageRoot } from './package-tools.js';
+const require = createRequire(import.meta.url);
+const sdkPackageRoot = resolve(dirname(require.resolve('@treeseed/sdk')), '..');
+const npmCacheDir = resolve(tmpdir(), 'treeseed-npm-cache');
+const textExtensions = new Set(['.js', '.ts', '.mjs', '.cjs', '.d.js', '.json', '.md']);
+const forbiddenPatterns = [
+    /['"`]file:[^'"`\n]+['"`]/,
+    /['"`]workspace:[^'"`\n]+['"`]/,
+    /['"`](?:\.\.\/|\.\/)[^'"`\n]*src\/[^'"`\n]*\.(?:[cm]?js|ts|tsx|json|astro|css)['"`]/,
+    /['"`][^'"`\n]*\/packages\/[^'"`\n]*\/src\/[^'"`\n]*['"`]/,
+];
+function run(command, args, cwd = packageRoot, capture = false) {
+    const result = spawnSync(command, args, {
+        cwd,
+        stdio: capture ? 'pipe' : 'inherit',
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            npm_config_cache: npmCacheDir,
+            NPM_CONFIG_CACHE: npmCacheDir,
+        },
+    });
+    if (result.status !== 0) {
+        throw new Error(result.stderr?.trim() || result.stdout?.trim() || `${command} ${args.join(' ')} failed`);
+    }
+    return (result.stdout ?? '').trim();
+}
+function walkFiles(root) {
+    const files = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const fullPath = join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...walkFiles(fullPath));
+            continue;
+        }
+        files.push(fullPath);
+    }
+    return files;
+}
+function scanDirectory(root) {
+    for (const filePath of walkFiles(root)) {
+        if (!textExtensions.has(extname(filePath)))
+            continue;
+        const source = readFileSync(filePath, 'utf8');
+        for (const pattern of forbiddenPatterns) {
+            if (pattern.test(source)) {
+                throw new Error(`${filePath} contains forbidden publish reference matching ${pattern}.`);
+            }
+        }
+    }
+}
+function resolveNodeModulesRoot() {
+    let lastCandidate = null;
+    let current = packageRoot;
+    while (true) {
+        const candidate = resolve(current, 'node_modules');
+        try {
+            readdirSync(candidate);
+            lastCandidate = candidate;
+        }
+        catch {
+        }
+        const parent = resolve(current, '..');
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    if (lastCandidate) {
+        return lastCandidate;
+    }
+    throw new Error(`Unable to locate node_modules for ${packageRoot}.`);
+}
+function mirrorDependencies(tempRoot) {
+    const sharedNodeModules = resolveNodeModulesRoot();
+    for (const entry of readdirSync(sharedNodeModules, { withFileTypes: true })) {
+        if (entry.name === '.bin' || entry.name === '@treeseed') {
+            continue;
+        }
+        const targetPath = resolve(tempRoot, 'node_modules', entry.name);
+        mkdirSync(dirname(targetPath), { recursive: true });
+        symlinkSync(resolve(sharedNodeModules, entry.name), targetPath, 'dir');
+    }
+}
+function pack(root, fallbackName) {
+    const output = run('npm', ['pack', '--ignore-scripts', '--cache', npmCacheDir], root, true);
+    const filename = output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .at(-1)
+        ?? readdirSync(root, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.tgz'))
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' }))
+            .at(-1)
+        ?? fallbackName;
+    return resolve(root, filename);
+}
+function installPackagedPackage(extractRoot, tempRoot, tarballPath, folderName) {
+    mkdirSync(resolve(tempRoot, 'node_modules', '@treeseed'), { recursive: true });
+    run('tar', ['-xzf', tarballPath, '-C', extractRoot]);
+    run('cp', ['-R', resolve(extractRoot, 'package'), resolve(tempRoot, 'node_modules', '@treeseed', folderName)]);
+    rmSync(resolve(extractRoot, 'package'), { recursive: true, force: true });
+}
+function isInstalledDependencyPackage(root) {
+    return root.includes(`${process.platform === 'win32' ? '\\' : '/'}node_modules${process.platform === 'win32' ? '\\' : '/'}`);
+}
+function installDependencyPackage(root, extractRoot, tempRoot, folderName, fallbackName) {
+    if (isInstalledDependencyPackage(root) && existsSync(resolve(root, 'dist')) && existsSync(resolve(root, 'package.json'))) {
+        const targetRoot = resolve(tempRoot, 'node_modules', '@treeseed', folderName);
+        mkdirSync(resolve(tempRoot, 'node_modules', '@treeseed'), { recursive: true });
+        cpSync(root, targetRoot, {
+            recursive: true,
+            filter(source) {
+                const relativePath = source.slice(root.length).replace(/^[/\\]/, '');
+                if (!relativePath) {
+                    return true;
+                }
+                return !(relativePath === 'node_modules'
+                    || relativePath.startsWith(`node_modules${process.platform === 'win32' ? '\\' : '/'}`));
+            },
+        });
+        return;
+    }
+    const tarballPath = pack(root, fallbackName);
+    installPackagedPackage(extractRoot, tempRoot, tarballPath, folderName);
+}
+run('npm', ['run', 'lint']);
+scanDirectory(resolve(packageRoot, 'dist'));
+run('npm', ['run', 'test:smoke']);
+const stageRoot = mkdtempSync(join(tmpdir(), 'treeseed-agent-release-'));
+const extractRoot = resolve(stageRoot, 'extract');
+const installRoot = resolve(stageRoot, 'install');
+try {
+    mkdirSync(extractRoot, { recursive: true });
+    const agentTarball = pack(packageRoot, 'treeseed-agent.tgz');
+    installDependencyPackage(sdkPackageRoot, extractRoot, installRoot, 'sdk', 'treeseed-sdk.tgz');
+    installPackagedPackage(extractRoot, installRoot, agentTarball, 'agent');
+    mirrorDependencies(installRoot);
+    writeFileSync(resolve(installRoot, 'package.json'), `${JSON.stringify({ name: 'treeseed-agent-smoke', private: true, type: 'module' }, null, 2)}\n`, 'utf8');
+    run(process.execPath, ['node_modules/@treeseed/agent/dist/scripts/treeseed-agents.js', '--help'], installRoot);
+    console.log('Agent packed-install bin smoke passed.');
+}
+finally {
+    rmSync(stageRoot, { recursive: true, force: true });
+}

package/dist/scripts/test-smoke.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/test-smoke.js

@@ -0,0 +1,23 @@
+import { createAgentTestRuntime } from '../agents/testing/e2e-harness.js';
+const runtime = await createAgentTestRuntime({
+    executionMode: 'stub',
+    databaseMode: 'memory',
+});
+try {
+    await runtime.seedObjectives([{ slug: 'release-smoke-objective' }]);
+    await runtime.seedQuestions([
+        {
+            slug: 'release-smoke-question',
+            relatedObjectives: ['release-smoke-objective'],
+        },
+    ]);
+    await runtime.runAgent('planner-agent');
+    const runs = await runtime.readRunLogs();
+    if (runs.length === 0) {
+        throw new Error('Agent smoke did not produce any run logs.');
+    }
+    console.log(`Agent smoke passed with ${runs.length} run log(s).`);
+}
+finally {
+    await runtime.cleanup();
+}

package/dist/scripts/treeseed-agent-api.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/scripts/treeseed-agent-api.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const apiServerPath = fileURLToPath(new URL('../api/server.js', import.meta.url));
+const command = process.argv[2] ?? 'start';
+const forwardedArgs = command === 'start' || command === 'dev' ? process.argv.slice(3) : process.argv.slice(2);
+if (command === '--help' || command === '-h' || command === 'help') {
+    process.stdout.write([
+        'treeseed-agent-api <command>',
+        '',
+        'Commands:',
+        '  start    Start the Treeseed agent API server',
+        '  dev      Start the Treeseed agent API server for local development',
+        '',
+    ].join('\n'));
+    process.exit(0);
+}
+const child = spawn(process.execPath, [apiServerPath, ...forwardedArgs], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: process.env,
+});
+child.on('exit', (code) => {
+    process.exit(code ?? 1);
+});

package/dist/scripts/treeseed-agent-service.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/scripts/treeseed-agent-service.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const services = new Map([
+    ['manager', '../services/manager.js'],
+    ['worker', '../services/worker.js'],
+    ['workday-manager', '../services/workday-manager.js'],
+    ['workday-start', '../services/workday-start.js'],
+    ['workday-report', '../services/workday-report.js'],
+    ['remote-runner', '../services/remote-runner.js'],
+    ['agents', '../services/agents.js'],
+]);
+const command = process.argv[2] ?? 'help';
+if (command === '--help' || command === '-h' || command === 'help') {
+    process.stdout.write([
+        'treeseed-agent-service <service>',
+        '',
+        'Services:',
+        ...services.keys(),
+        '',
+    ].join('\n'));
+    process.exit(0);
+}
+const servicePath = services.get(command);
+if (!servicePath) {
+    process.stderr.write(`Unknown Treeseed agent service "${command}".\n`);
+    process.exit(1);
+}
+const child = spawn(process.execPath, [fileURLToPath(new URL(servicePath, import.meta.url)), ...process.argv.slice(3)], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: process.env,
+});
+child.on('exit', (code) => {
+    process.exit(code ?? 1);
+});

package/dist/scripts/treeseed-agents.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/scripts/treeseed-agents.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const packageRoot = fileURLToPath(new URL('..', import.meta.url));
+const cliScriptPath = fileURLToPath(new URL('../agents/cli.js', import.meta.url));
+const child = spawn(process.execPath, [cliScriptPath, ...process.argv.slice(2)], {
+    cwd: packageRoot,
+    stdio: 'inherit',
+    env: process.env,
+});
+child.on('exit', (code) => {
+    process.exit(code ?? 1);
+});

package/dist/services/agents.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+export declare function resolveAgentsServiceConfig(): {
+    serviceName: string;
+    pollIntervalMs: number;
+};
+export declare function runAgentsCycle(): Promise<{
+    ok: boolean;
+    processed: number;
+    results: {
+        slug: string;
+        result: import("../index.ts").AgentExecutionResult | {
+            status: string;
+            summary: string;
+        };
+    }[];
+}>;
+export declare function startAgentsLoop(): Promise<void>;

package/dist/services/agents.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { AgentKernel } from "../agents/kernel/agent-kernel.js";
+import { createServiceSdk, resolveServiceRepoRoot } from "./common.js";
+function integerFromEnv(name, fallback) {
+  const value = process.env[name];
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function resolveAgentsServiceConfig() {
+  return {
+    serviceName: process.env.TREESEED_AGENTS_SERVICE_NAME?.trim() || "agents",
+    pollIntervalMs: integerFromEnv("TREESEED_AGENTS_POLL_INTERVAL_MS", 3e4)
+  };
+}
+async function runAgentsCycle() {
+  const sdk = createServiceSdk();
+  const kernel = new AgentKernel(sdk, resolveServiceRepoRoot());
+  const results = await kernel.runCycle();
+  return {
+    ok: true,
+    processed: results.length,
+    results
+  };
+}
+async function startAgentsLoop() {
+  const config = resolveAgentsServiceConfig();
+  for (; ; ) {
+    try {
+      await runAgentsCycle();
+    } 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 startAgentsLoop();
+}
+export {
+  resolveAgentsServiceConfig,
+  runAgentsCycle,
+  startAgentsLoop
+};

package/dist/services/common.d.ts

@@ -0,0 +1,66 @@
+import { AgentSdk } from '@treeseed/sdk';
+import { CloudflareQueuePullClient } from '@treeseed/sdk/remote';
+import type { SdkQueueMessageEnvelope } from '@treeseed/sdk';
+export declare function resolveServiceRepoRoot(): string;
+export declare function createServiceSdk(): AgentSdk;
+export declare function createQueueClient(): CloudflareQueuePullClient | null;
+export declare function createQueuePushClient(): {
+    enqueue(request: {
+        message: SdkQueueMessageEnvelope;
+        delaySeconds?: number;
+    }): Promise<void>;
+} | null;
+export declare function queueEnvelopeForTask(task: Record<string, unknown>): SdkQueueMessageEnvelope;
+export declare function enqueueTaskFromSdk(sdk: AgentSdk, request: {
+    taskId: string;
+    queueName?: string;
+    deliveryDelaySeconds?: number;
+    actor?: string;
+}): Promise<{
+    ok: boolean;
+    taskId: string;
+    queued: boolean;
+}>;
+export declare function buildTaskContext(sdk: AgentSdk, taskId: string): Promise<{
+    agent: Record<string, unknown> | import("@treeseed/sdk").SdkContentEntry | null;
+    task: import("@treeseed/sdk").SdkTaskEntity | null;
+    workDay: import("@treeseed/sdk").SdkWorkDayEntity | null;
+    graph: Record<string, unknown> | null;
+}>;
+export declare function seedRootTasks(sdk: AgentSdk, workDayId: string): Promise<import("@treeseed/sdk").SdkJsonEnvelope<import("@treeseed/sdk").SdkTaskEntity | null>[]>;
+export declare function seedGraphRefreshTask(sdk: AgentSdk, request: {
+    workDayId: string;
+    projectId: string;
+    repositoryId?: string | null;
+    actor?: string;
+}): Promise<import("@treeseed/sdk").SdkTaskEntity | null>;
+export declare function startAndSeedWorkday(sdk: AgentSdk, request: {
+    id?: string;
+    projectId: string;
+    capacityBudget: number;
+    actor?: string;
+}): Promise<{
+    ok: boolean;
+    workDay: import("@treeseed/sdk").SdkWorkDayEntity | null;
+    seededTasks: (import("@treeseed/sdk").SdkTaskEntity | null)[];
+}>;
+export declare function resolveManagerConfig(): {
+    host: string;
+    port: number;
+    projectId: string;
+    defaultCapacityBudget: number;
+};
+export declare function resolveWorkerConfig(): {
+    workerId: string;
+    batchSize: number;
+    maxLocalWorkers: number;
+    runnerServiceName: string;
+    volumeRoot: string;
+    volumeIdentity: string;
+    projectId: string;
+    environment: string;
+    visibilityTimeoutMs: number;
+    pollIntervalMs: number;
+    idleExitMs: number;
+    leaseSeconds: number;
+};