@exaudeus/workrail 3.25.0 → 3.26.0

package/dist/cli-worktrain.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const promises_1 = require("readline/promises");
+const process_1 = require("process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const crypto_1 = require("crypto");
+const interpret_result_js_1 = require("./cli/interpret-result.js");
+const index_js_1 = require("./cli/commands/index.js");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const program = new commander_1.Command();
+program
+    .name('worktrain')
+    .description('WorkTrain daemon management')
+    .version('0.0.3');
+program
+    .command('init')
+    .description('Guided setup for WorkTrain daemon: credentials, workspace, triggers.yml, daemon-soul.md, smoke test')
+    .option('-y, --yes', 'Skip interactive prompts and use safe defaults (for CI / non-TTY use)')
+    .action(async (options) => {
+    if (!options.yes && !process_1.stdin.isTTY) {
+        console.warn('Warning: stdin is not a TTY. Interactive prompts may not work as expected.\n' +
+            'Run with --yes to use safe defaults without prompting.');
+    }
+    const rl = (0, promises_1.createInterface)({ input: process_1.stdin, output: process_1.stdout, terminal: true });
+    try {
+        const result = await (0, index_js_1.executeWorktrainInitCommand)({
+            prompt: async (question, defaultValue) => {
+                if (options.yes) {
+                    return defaultValue ?? '';
+                }
+                const answer = await rl.question(question);
+                return answer.trim() || (defaultValue ?? '');
+            },
+            mkdir: (p, opts) => fs_1.default.promises.mkdir(p, opts),
+            readFile: (p) => fs_1.default.promises.readFile(p, 'utf-8'),
+            writeFile: (p, content) => fs_1.default.promises.writeFile(p, content, 'utf-8'),
+            exists: async (p) => {
+                try {
+                    await fs_1.default.promises.access(p);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+            homedir: os_1.default.homedir,
+            cwd: process.cwd,
+            joinPath: path_1.default.join,
+            runSmoke: async () => {
+                try {
+                    const { stdout } = await execFileAsync('workrail', ['list'], {
+                        timeout: 10000,
+                    });
+                    return { ok: true, output: stdout.trim() };
+                }
+                catch (err) {
+                    const message = err instanceof Error
+                        ? err.message
+                        : String(err);
+                    return { ok: false, output: message };
+                }
+            },
+            print: (line) => console.log(line),
+            env: process_1.env,
+        }, { yes: options.yes });
+        (0, interpret_result_js_1.interpretCliResultWithoutDI)(result);
+    }
+    finally {
+        rl.close();
+    }
+});
+program
+    .command('tell <message>')
+    .description('Queue an async message for the WorkTrain daemon (~/.workrail/message-queue.jsonl)')
+    .option('-w, --workspace <name>', 'Workspace hint for the daemon (optional)')
+    .addOption(new commander_1.Option('-p, --priority <level>', 'Message priority: high, normal, or low')
+    .choices(['high', 'normal', 'low'])
+    .default('normal'))
+    .action(async (message, options) => {
+    const result = await (0, index_js_1.executeWorktrainTellCommand)(message, {
+        appendFile: (p, content) => fs_1.default.promises.appendFile(p, content, 'utf-8'),
+        mkdir: (p, opts) => fs_1.default.promises.mkdir(p, opts),
+        homedir: os_1.default.homedir,
+        joinPath: path_1.default.join,
+        print: (line) => console.log(line),
+        now: () => new Date().toISOString(),
+        generateId: () => (0, crypto_1.randomUUID)(),
+    }, {
+        workspace: options.workspace,
+        priority: (options.priority ?? 'normal'),
+    });
+    (0, interpret_result_js_1.interpretCliResultWithoutDI)(result);
+});
+program
+    .command('inbox')
+    .description('Read unread messages from the WorkTrain daemon (~/.workrail/outbox.jsonl)')
+    .option('-w, --watch', 'Watch for new messages in real time (not yet implemented)')
+    .action(async (options) => {
+    const result = await (0, index_js_1.executeWorktrainInboxCommand)({
+        readFile: (p) => fs_1.default.promises.readFile(p, 'utf-8'),
+        writeFile: (p, content) => fs_1.default.promises.writeFile(p, content, 'utf-8'),
+        mkdir: (p, opts) => fs_1.default.promises.mkdir(p, opts),
+        homedir: os_1.default.homedir,
+        joinPath: path_1.default.join,
+        print: (line) => console.log(line),
+    }, { watch: options.watch });
+    (0, interpret_result_js_1.interpretCliResultWithoutDI)(result);
+});
+program
+    .command('spawn')
+    .description('Start a workflow session non-interactively. Prints session handle to stdout.')
+    .requiredOption('-w, --workflow <id>', 'Workflow ID to run')
+    .requiredOption('-g, --goal <text>', 'One-sentence goal for the workflow session')
+    .requiredOption('-W, --workspace <path>', 'Absolute path to the workspace directory')
+    .option('-p, --port <n>', 'Console HTTP server port (default: auto-discover from lock file, then 3456)', parseInt)
+    .action(async (options) => {
+    const result = await (0, index_js_1.executeWorktrainSpawnCommand)({
+        fetch: (url, opts) => globalThis.fetch(url, opts),
+        readFile: (p) => fs_1.default.promises.readFile(p, 'utf-8'),
+        stdout: (line) => process.stdout.write(line + '\n'),
+        stderr: (line) => process.stderr.write(line + '\n'),
+        homedir: os_1.default.homedir,
+        joinPath: path_1.default.join,
+        pathIsAbsolute: path_1.default.isAbsolute,
+        statPath: (p) => fs_1.default.promises.stat(p),
+    }, {
+        workflow: options.workflow,
+        goal: options.goal,
+        workspace: options.workspace,
+        port: options.port,
+    });
+    (0, interpret_result_js_1.interpretCliResultWithoutDI)(result);
+});
+program
+    .command('await')
+    .description('Block until workflow sessions complete. Prints JSON results to stdout.')
+    .requiredOption('-s, --sessions <handles>', 'Comma-separated list of session handles to wait for')
+    .option('-m, --mode <mode>', "Wait mode: 'all' (default) or 'any'", 'all')
+    .option('-t, --timeout <duration>', 'Timeout (e.g. "30m", "1h", "90s"). Default: 30m', '30m')
+    .option('-p, --port <n>', 'Console HTTP server port (default: auto-discover from lock file, then 3456)', parseInt)
+    .action(async (options) => {
+    const mode = options.mode === 'any' ? 'any' : 'all';
+    const result = await (0, index_js_1.executeWorktrainAwaitCommand)({
+        fetch: (url) => globalThis.fetch(url),
+        readFile: (p) => fs_1.default.promises.readFile(p, 'utf-8'),
+        stdout: (line) => process.stdout.write(line + '\n'),
+        stderr: (line) => process.stderr.write(line + '\n'),
+        homedir: os_1.default.homedir,
+        joinPath: path_1.default.join,
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        now: () => Date.now(),
+    }, {
+        sessions: options.sessions,
+        mode,
+        timeout: options.timeout,
+        port: options.port,
+    });
+    (0, interpret_result_js_1.interpretCliResultWithoutDI)(result);
+});
+program.parse();

package/dist/cli.js

@@ -49,6 +49,7 @@ const validation_js_1 = require("./application/validation.js");
 const validate_workflow_file_js_1 = require("./application/use-cases/validate-workflow-file.js");
 const workflow_compiler_js_1 = require("./application/services/workflow-compiler.js");
 const v1_to_v2_shim_js_1 = require("./v2/read-only/v1-to-v2-shim.js");
+const config_file_js_1 = require("./config/config-file.js");
 const interpret_result_js_1 = require("./cli/interpret-result.js");
 const index_js_1 = require("./cli/commands/index.js");
 const program = new commander_1.Command();
@@ -186,7 +187,7 @@ program
 program
     .command('daemon')
     .description('Start the autonomous WorkRail daemon (trigger webhook server on port 3200)')
-    .option('-w, --workspace <path>', 'Path to workspace containing triggers.yml', process.cwd())
+    .option('-w, --workspace <path>', 'Path to workspace containing triggers.yml')
     .action(async (options) => {
     const { startTriggerListener } = await Promise.resolve().then(() => __importStar(require('./trigger/trigger-listener.js')));
     await (0, container_js_1.initializeContainer)({ runtimeMode: { kind: 'cli' } });
@@ -199,6 +200,15 @@ program
         process.exit(1);
     }
     const ctx = v2Guard.ctx;
+    let workspacePath;
+    if (options.workspace) {
+        workspacePath = options.workspace;
+    }
+    else {
+        const configResult = (0, config_file_js_1.loadWorkrailConfigFile)();
+        const configWorkspace = configResult.kind === 'ok' ? configResult.value['WORKRAIL_DEFAULT_WORKSPACE'] : undefined;
+        workspacePath = configWorkspace?.trim() || process.cwd();
+    }
     const usesBedrock = !!process.env['AWS_PROFILE'] || !!process.env['AWS_ACCESS_KEY_ID'];
     const apiKey = process.env['ANTHROPIC_API_KEY'];
     if (!usesBedrock && !apiKey) {
@@ -206,7 +216,7 @@ program
         process.exit(1);
     }
     const handle = await startTriggerListener(ctx, {
-        workspacePath: options.workspace,
+        workspacePath,
         apiKey: apiKey,
         env: process.env,
     });
@@ -219,7 +229,7 @@ program
         process.exit(1);
     }
     console.log(`WorkRail daemon running on port ${handle.port}`);
-    console.log(`Workspace: ${options.workspace}`);
+    console.log(`Workspace: ${workspacePath}`);
     console.log('Waiting for webhook triggers...');
     const shutdown = async () => {
         console.log('\nShutting down daemon...');

package/dist/config/config-file.d.ts

@@ -1,4 +1,5 @@
 import type { Result } from '../runtime/result.js';
+import type { WorkspaceConfig } from '../trigger/types.js';
 export type ConfigFileError = {
     readonly _tag: 'ConfigFileError';
     readonly message: string;
@@ -6,3 +7,4 @@ export type ConfigFileError = {
 };
 export declare function ensureWorkrailConfigFile(): void;
 export declare function loadWorkrailConfigFile(): Result<Record<string, string>, ConfigFileError>;
+export declare function loadWorkspacesFromConfigFile(): Result<Record<string, WorkspaceConfig>, never>;

package/dist/config/config-file.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureWorkrailConfigFile = ensureWorkrailConfigFile;
 exports.loadWorkrailConfigFile = loadWorkrailConfigFile;
+exports.loadWorkspacesFromConfigFile = loadWorkspacesFromConfigFile;
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
@@ -65,6 +66,8 @@ const ALLOWED_CONFIG_FILE_KEYS = new Set([
     'WORKRAIL_DATA_DIR',
     'WORKRAIL_CACHE_DIR',
     'WORKRAIL_JSON_RESPONSES',
+    'WORKRAIL_DEFAULT_WORKSPACE',
+    'maxConcurrentSessions',
 ]);
 const ConfigFileSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.string());
 const CONFIG_FILE_TEMPLATE = `{
@@ -139,3 +142,55 @@ function loadWorkrailConfigFile() {
     }
     return (0, result_js_1.ok)(validated);
 }
+const WorkspaceConfigEntrySchema = zod_1.z.object({
+    path: zod_1.z.string().min(1),
+    soulFile: zod_1.z.string().min(1).optional(),
+});
+function loadWorkspacesFromConfigFile() {
+    if (process.env['VITEST'])
+        return (0, result_js_1.ok)({});
+    const configPath = path.join(os.homedir(), '.workrail', 'config.json');
+    let rawContent;
+    try {
+        rawContent = fs.readFileSync(configPath, 'utf-8');
+    }
+    catch {
+        return (0, result_js_1.ok)({});
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawContent);
+    }
+    catch {
+        return (0, result_js_1.ok)({});
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return (0, result_js_1.ok)({});
+    }
+    const workspacesRaw = parsed['workspaces'];
+    if (workspacesRaw === undefined || workspacesRaw === null) {
+        return (0, result_js_1.ok)({});
+    }
+    if (typeof workspacesRaw !== 'object' || Array.isArray(workspacesRaw)) {
+        console.warn('[WorkRail] config file: "workspaces" must be an object (map of name -> { path, soulFile? }). Ignoring.');
+        return (0, result_js_1.ok)({});
+    }
+    const result = {};
+    for (const [name, entry] of Object.entries(workspacesRaw)) {
+        const parseResult = WorkspaceConfigEntrySchema.safeParse(entry);
+        if (!parseResult.success) {
+            console.warn(`[WorkRail] config file: workspace "${name}" has invalid shape -- skipped. ` +
+                `Expected { path: string; soulFile?: string }. ` +
+                `Issues: ${parseResult.error.issues.map((i) => i.message).join(', ')}`);
+            continue;
+        }
+        const data = parseResult.data;
+        if (data.soulFile?.startsWith('~/')) {
+            result[name] = { ...data, soulFile: path.join(os.homedir(), data.soulFile.slice(2)) };
+        }
+        else {
+            result[name] = data;
+        }
+    }
+    return (0, result_js_1.ok)(result);
+}

package/dist/daemon/agent-loop.d.ts

@@ -0,0 +1,90 @@
+import type Anthropic from '@anthropic-ai/sdk';
+export interface AgentClientInterface {
+    messages: {
+        create(params: Anthropic.MessageCreateParamsNonStreaming, options?: {
+            signal?: AbortSignal;
+        }): Promise<Anthropic.Message>;
+    };
+}
+export interface AgentToolResult<T> {
+    readonly content: ReadonlyArray<{
+        readonly type: 'text';
+        readonly text: string;
+    }>;
+    readonly details: T;
+}
+export interface AgentTool {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Record<string, unknown>;
+    readonly label: string;
+    execute(toolCallId: string, params: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
+}
+export type AgentEvent = {
+    readonly type: 'turn_end';
+    readonly toolResults: ReadonlyArray<AgentToolCallResult>;
+} | {
+    readonly type: 'agent_end';
+};
+export interface AgentToolCallResult {
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly result: AgentToolResult<unknown> | null;
+    readonly isError: boolean;
+}
+export type AgentInternalMessage = AgentInternalUserMessage | AgentInternalAssistantMessage | AgentInternalToolResultMessage;
+export interface AgentInternalUserMessage {
+    readonly role: 'user';
+    readonly content: string;
+    readonly timestamp: number;
+}
+export interface AgentInternalAssistantMessage {
+    readonly role: 'assistant';
+    readonly stopReason: 'tool_use' | 'end_turn' | 'error';
+    readonly errorMessage?: string;
+    readonly content: ReadonlyArray<Anthropic.ContentBlock>;
+}
+export interface AgentInternalToolResultMessage {
+    readonly role: 'user';
+    readonly content: ReadonlyArray<Anthropic.ToolResultBlockParam>;
+}
+export interface AgentLoopOptions {
+    readonly systemPrompt: string;
+    readonly tools: readonly AgentTool[];
+    readonly client: AgentClientInterface;
+    readonly modelId: string;
+    readonly maxTokens?: number;
+    readonly toolExecution?: 'sequential';
+}
+export declare class AgentLoop {
+    private readonly _options;
+    private readonly _listeners;
+    private readonly _steerQueue;
+    private _messages;
+    private _abortController;
+    private _isRunning;
+    private _aborted;
+    constructor(options: AgentLoopOptions);
+    subscribe(listener: (event: AgentEvent) => Promise<void> | void): () => void;
+    steer(message: {
+        role: 'user';
+        content: string;
+        timestamp: number;
+    }): void;
+    abort(): void;
+    get state(): {
+        readonly messages: ReadonlyArray<AgentInternalMessage>;
+    };
+    prompt(message: {
+        role: 'user';
+        content: string;
+        timestamp: number;
+    }): Promise<void>;
+    private _runLoop;
+    private _executeTools;
+    private _drainSteerQueue;
+    private _emitEvent;
+    private _appendErrorMessage;
+    private _buildApiMessages;
+    private _mapStopReason;
+}

package/dist/daemon/agent-loop.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentLoop = void 0;
+class AgentLoop {
+    constructor(options) {
+        this._listeners = [];
+        this._steerQueue = [];
+        this._messages = [];
+        this._abortController = new AbortController();
+        this._isRunning = false;
+        this._aborted = false;
+        this._options = options;
+    }
+    subscribe(listener) {
+        this._listeners.push(listener);
+        return () => {
+            const idx = this._listeners.indexOf(listener);
+            if (idx !== -1)
+                this._listeners.splice(idx, 1);
+        };
+    }
+    steer(message) {
+        this._steerQueue.push({ role: 'user', content: message.content, timestamp: message.timestamp });
+    }
+    abort() {
+        this._aborted = true;
+        this._abortController.abort();
+    }
+    get state() {
+        return { messages: this._messages };
+    }
+    async prompt(message) {
+        if (!this._aborted) {
+            this._abortController = new AbortController();
+        }
+        this._isRunning = true;
+        this._messages.push({ role: 'user', content: message.content, timestamp: message.timestamp });
+        try {
+            await this._runLoop();
+        }
+        finally {
+            this._isRunning = false;
+        }
+    }
+    async _runLoop() {
+        const { client, modelId, systemPrompt, tools, maxTokens = 8192 } = this._options;
+        while (true) {
+            if (this._aborted || this._abortController.signal.aborted) {
+                this._appendErrorMessage('aborted');
+                await this._emitEvent({ type: 'agent_end' });
+                return;
+            }
+            const apiMessages = this._buildApiMessages();
+            const apiTools = tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                input_schema: t.inputSchema,
+            }));
+            let response;
+            try {
+                response = await client.messages.create({
+                    model: modelId,
+                    system: systemPrompt,
+                    messages: apiMessages,
+                    tools: apiTools,
+                    max_tokens: maxTokens,
+                }, { signal: this._abortController.signal });
+            }
+            catch (err) {
+                const isAbort = this._abortController.signal.aborted ||
+                    (err instanceof Error && err.name === 'AbortError');
+                const message = err instanceof Error ? err.message : String(err);
+                this._appendErrorMessage(isAbort ? 'aborted' : message);
+                await this._emitEvent({ type: 'agent_end' });
+                return;
+            }
+            const stopReason = this._mapStopReason(response.stop_reason);
+            const assistantMsg = {
+                role: 'assistant',
+                stopReason,
+                content: response.content,
+            };
+            this._messages.push(assistantMsg);
+            const toolUseBlocks = response.content.filter((block) => block.type === 'tool_use');
+            if (stopReason === 'tool_use' || toolUseBlocks.length > 0) {
+                const toolResults = await this._executeTools(toolUseBlocks);
+                const toolResultBlocks = toolResults.map((r) => ({
+                    type: 'tool_result',
+                    tool_use_id: r.toolCallId,
+                    content: r.result?.content.map((c) => ({ type: 'text', text: c.text })) ?? [
+                        { type: 'text', text: r.isError ? `Tool error: ${r.toolName}` : '(no output)' },
+                    ],
+                    is_error: r.isError,
+                }));
+                this._messages.push({ role: 'user', content: toolResultBlocks });
+                await this._emitEvent({ type: 'turn_end', toolResults });
+                const steered = this._drainSteerQueue();
+                if (steered > 0) {
+                    continue;
+                }
+                continue;
+            }
+            if (stopReason === 'end_turn') {
+                await this._emitEvent({ type: 'turn_end', toolResults: [] });
+                const steered = this._drainSteerQueue();
+                if (steered > 0) {
+                    continue;
+                }
+                await this._emitEvent({ type: 'agent_end' });
+                return;
+            }
+            const errorMsg = assistantMsg.errorMessage ?? `Unexpected stop_reason: ${response.stop_reason ?? 'unknown'}`;
+            this._appendErrorMessage(errorMsg);
+            await this._emitEvent({ type: 'agent_end' });
+            return;
+        }
+    }
+    async _executeTools(toolUseBlocks) {
+        const results = [];
+        for (const block of toolUseBlocks) {
+            if (this._abortController.signal.aborted) {
+                results.push({
+                    toolCallId: block.id,
+                    toolName: block.name,
+                    result: null,
+                    isError: true,
+                });
+                continue;
+            }
+            const tool = this._options.tools.find((t) => t.name === block.name);
+            if (!tool) {
+                results.push({
+                    toolCallId: block.id,
+                    toolName: block.name,
+                    result: {
+                        content: [{ type: 'text', text: `Unknown tool: ${block.name}` }],
+                        details: null,
+                    },
+                    isError: true,
+                });
+                continue;
+            }
+            const params = (block.input ?? {});
+            const result = await tool.execute(block.id, params);
+            results.push({
+                toolCallId: block.id,
+                toolName: block.name,
+                result,
+                isError: false,
+            });
+        }
+        return results;
+    }
+    _drainSteerQueue() {
+        let count = 0;
+        while (this._steerQueue.length > 0) {
+            const msg = this._steerQueue.shift();
+            this._messages.push(msg);
+            count++;
+        }
+        return count;
+    }
+    async _emitEvent(event) {
+        for (const listener of this._listeners) {
+            await listener(event);
+        }
+    }
+    _appendErrorMessage(errorMessage) {
+        this._messages.push({
+            role: 'assistant',
+            stopReason: 'error',
+            errorMessage,
+            content: [],
+        });
+    }
+    _buildApiMessages() {
+        const result = [];
+        for (const msg of this._messages) {
+            if (msg.role === 'assistant') {
+                const assistantMsg = msg;
+                result.push({
+                    role: 'assistant',
+                    content: assistantMsg.content,
+                });
+            }
+            else if (msg.role === 'user') {
+                const userMsg = msg;
+                if (typeof userMsg.content === 'string') {
+                    result.push({ role: 'user', content: userMsg.content });
+                }
+                else {
+                    result.push({
+                        role: 'user',
+                        content: userMsg.content,
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    _mapStopReason(stopReason) {
+        switch (stopReason) {
+            case 'tool_use':
+                return 'tool_use';
+            case 'end_turn':
+                return 'end_turn';
+            case 'max_tokens':
+                return 'end_turn';
+            default:
+                return 'error';
+        }
+    }
+}
+exports.AgentLoop = AgentLoop;

package/dist/daemon/pi-mono-loader.d.ts

@@ -1,5 +0,0 @@
-export type { Agent, AgentTool, AgentToolResult, AgentEvent, AgentLoopConfig } from '@mariozechner/pi-agent-core';
-export type { Model, TSchema } from '@mariozechner/pi-ai';
-type AnyModule = Record<string, any>;
-export declare function loadPiAi(): Promise<AnyModule>;
-export declare function loadPiAgentCore(): Promise<AnyModule>;

package/dist/daemon/pi-mono-loader.js

@@ -1,65 +1 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadPiAi = loadPiAi;
-exports.loadPiAgentCore = loadPiAgentCore;
-const esmImport = new Function('specifier', 'return import(specifier)');
-let _piAi = null;
-let _piAgentCore = null;
-let _bedrockRegistered = false;
-async function loadPiAi() {
-    if (!_piAi) {
-        _piAi = await esmImport('@mariozechner/pi-ai');
-        if (!_bedrockRegistered) {
-            try {
-                const path = await Promise.resolve().then(() => __importStar(require('node:path')));
-                const bedrockPath = path.resolve(__dirname, '..', '..', 'node_modules', '@mariozechner', 'pi-ai', 'dist', 'bedrock-provider.js');
-                const bedrockMod = await esmImport(`file://${bedrockPath}`).catch(() => null);
-                if (bedrockMod?.bedrockProviderModule && _piAi.setBedrockProviderModule) {
-                    _piAi.setBedrockProviderModule(bedrockMod.bedrockProviderModule);
-                    _bedrockRegistered = true;
-                }
-            }
-            catch {
-            }
-        }
-    }
-    return _piAi;
-}
-async function loadPiAgentCore() {
-    if (!_piAgentCore)
-        _piAgentCore = await esmImport('@mariozechner/pi-agent-core');
-    return _piAgentCore;
-}

package/dist/daemon/soul-template.d.ts

@@ -0,0 +1,2 @@
+export declare const DAEMON_SOUL_DEFAULT = "- Write code that follows the patterns already established in the codebase\n- Never skip tests. Run existing tests before and after changes\n- Prefer small, focused changes over large rewrites\n- If a step asks you to write code, write actual code -- do not write pseudocode or placeholders\n- Commit your work when you complete a logical unit";
+export declare const DAEMON_SOUL_TEMPLATE = "# WorkRail Daemon Soul\n#\n# This file is injected into every WorkRail Auto daemon session system prompt under\n# \"## Agent Rules and Philosophy\". Edit it to customize the agent's behavior for\n# your environment: coding conventions, commit style, tool preferences, etc.\n#\n# Changes take effect on the next daemon session -- no restart required.\n#\n# The defaults below reflect general best practices. Override them freely.\n\n- Write code that follows the patterns already established in the codebase\n- Never skip tests. Run existing tests before and after changes\n- Prefer small, focused changes over large rewrites\n- If a step asks you to write code, write actual code -- do not write pseudocode or placeholders\n- Commit your work when you complete a logical unit\n";