@a5c-ai/agent-platform 5.0.1-staging.04ca6ab00d21

package/dist/cost/types.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * Cost tracking type definitions and pricing constants for Babysitter SDK.
+ *
+ * Covers Anthropic Claude API token usage structures as seen in Claude Code
+ * session JSONL files, plus aggregation interfaces for run-level and
+ * cross-run cost reporting.
+ *
+ * Pricing source: https://docs.anthropic.com/en/docs/about-claude/pricing
+ * Last verified: 2026-04-05
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_PRICING_EXTENDED = exports.MODEL_PRICING = void 0;
+exports.calculateCostUsd = calculateCostUsd;
+exports.calculateCostUsdExtended = calculateCostUsdExtended;
+/**
+ * Pricing table for known Claude models.
+ *
+ * Keys use the API model identifier format (e.g. "claude-opus-4-6").
+ * Pricing sourced from https://docs.anthropic.com/en/docs/about-claude/pricing
+ *
+ * Cache-creation rates default to the 5-minute write multiplier (1.25x input).
+ * For fine-grained 5m vs 1h cost splits, use {@link MODEL_PRICING_EXTENDED}.
+ */
+exports.MODEL_PRICING = {
+    // --- Opus family ---
+    "claude-opus-4-6": {
+        inputPer1M: 5,
+        outputPer1M: 25,
+        cacheCreationPer1M: 6.25, // 1.25x input
+        cacheReadPer1M: 0.5, // 0.1x input
+    },
+    "claude-opus-4-5": {
+        inputPer1M: 5,
+        outputPer1M: 25,
+        cacheCreationPer1M: 6.25,
+        cacheReadPer1M: 0.5,
+    },
+    "claude-opus-4-1": {
+        inputPer1M: 15,
+        outputPer1M: 75,
+        cacheCreationPer1M: 18.75,
+        cacheReadPer1M: 1.5,
+    },
+    "claude-opus-4-0": {
+        inputPer1M: 15,
+        outputPer1M: 75,
+        cacheCreationPer1M: 18.75,
+        cacheReadPer1M: 1.5,
+    },
+    // --- Sonnet family ---
+    "claude-sonnet-4-6": {
+        inputPer1M: 3,
+        outputPer1M: 15,
+        cacheCreationPer1M: 3.75,
+        cacheReadPer1M: 0.3,
+    },
+    "claude-sonnet-4-5": {
+        inputPer1M: 3,
+        outputPer1M: 15,
+        cacheCreationPer1M: 3.75,
+        cacheReadPer1M: 0.3,
+    },
+    "claude-sonnet-4-0": {
+        inputPer1M: 3,
+        outputPer1M: 15,
+        cacheCreationPer1M: 3.75,
+        cacheReadPer1M: 0.3,
+    },
+    // --- Haiku family ---
+    "claude-haiku-4-5": {
+        inputPer1M: 1,
+        outputPer1M: 5,
+        cacheCreationPer1M: 1.25,
+        cacheReadPer1M: 0.1,
+    },
+    "claude-haiku-3-5": {
+        inputPer1M: 0.8,
+        outputPer1M: 4,
+        cacheCreationPer1M: 1,
+        cacheReadPer1M: 0.08,
+    },
+};
+exports.MODEL_PRICING_EXTENDED = {
+    "claude-opus-4-6": {
+        inputPer1M: 5,
+        outputPer1M: 25,
+        cacheCreationPer1M: 6.25,
+        cacheCreation5mPer1M: 6.25,
+        cacheCreation1hPer1M: 10,
+        cacheReadPer1M: 0.5,
+    },
+    "claude-opus-4-5": {
+        inputPer1M: 5,
+        outputPer1M: 25,
+        cacheCreationPer1M: 6.25,
+        cacheCreation5mPer1M: 6.25,
+        cacheCreation1hPer1M: 10,
+        cacheReadPer1M: 0.5,
+    },
+    "claude-opus-4-1": {
+        inputPer1M: 15,
+        outputPer1M: 75,
+        cacheCreationPer1M: 18.75,
+        cacheCreation5mPer1M: 18.75,
+        cacheCreation1hPer1M: 30,
+        cacheReadPer1M: 1.5,
+    },
+    "claude-opus-4-0": {
+        inputPer1M: 15,
+        outputPer1M: 75,
+        cacheCreationPer1M: 18.75,
+        cacheCreation5mPer1M: 18.75,
+        cacheCreation1hPer1M: 30,
+        cacheReadPer1M: 1.5,
+    },
+    "claude-sonnet-4-6": {
+        inputPer1M: 3,
+        outputPer1M: 15,
+        cacheCreationPer1M: 3.75,
+        cacheCreation5mPer1M: 3.75,
+        cacheCreation1hPer1M: 6,
+        cacheReadPer1M: 0.3,
+    },
+    "claude-sonnet-4-5": {
+        inputPer1M: 3,
+        outputPer1M: 15,
+        cacheCreationPer1M: 3.75,
+        cacheCreation5mPer1M: 3.75,
+        cacheCreation1hPer1M: 6,
+        cacheReadPer1M: 0.3,
+    },
+    "claude-sonnet-4-0": {
+        inputPer1M: 3,
+        outputPer1M: 15,
+        cacheCreationPer1M: 3.75,
+        cacheCreation5mPer1M: 3.75,
+        cacheCreation1hPer1M: 6,
+        cacheReadPer1M: 0.3,
+    },
+    "claude-haiku-4-5": {
+        inputPer1M: 1,
+        outputPer1M: 5,
+        cacheCreationPer1M: 1.25,
+        cacheCreation5mPer1M: 1.25,
+        cacheCreation1hPer1M: 2,
+        cacheReadPer1M: 0.1,
+    },
+    "claude-haiku-3-5": {
+        inputPer1M: 0.8,
+        outputPer1M: 4,
+        cacheCreationPer1M: 1,
+        cacheCreation5mPer1M: 1,
+        cacheCreation1hPer1M: 1.6,
+        cacheReadPer1M: 0.08,
+    },
+};
+/**
+ * Resolve pricing for a model identifier.
+ *
+ * Handles common variations: the API may return "claude-opus-4-6-20260301"
+ * or similar dated suffixes. We strip the date and try progressively
+ * shorter prefixes until we find a match.
+ */
+function resolvePricing(model) {
+    // Direct match first.
+    if (exports.MODEL_PRICING[model])
+        return exports.MODEL_PRICING[model];
+    // Strip date suffix (e.g. "claude-opus-4-6-20260301" -> "claude-opus-4-6").
+    const withoutDate = model.replace(/-\d{8}$/, "");
+    if (exports.MODEL_PRICING[withoutDate])
+        return exports.MODEL_PRICING[withoutDate];
+    // Try prefix matching (longest first).
+    const keys = Object.keys(exports.MODEL_PRICING).sort((a, b) => b.length - a.length);
+    for (const key of keys) {
+        if (withoutDate.startsWith(key))
+            return exports.MODEL_PRICING[key];
+    }
+    return undefined;
+}
+/**
+ * Calculate the USD cost for a single API interaction.
+ *
+ * Uses the blended cache-creation rate from {@link MODEL_PRICING}.
+ * For fine-grained 5m/1h splits, use {@link calculateCostUsdExtended}.
+ *
+ * @returns Cost in USD, or `undefined` if the model is unknown.
+ */
+function calculateCostUsd(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
+    const pricing = resolvePricing(model);
+    if (!pricing)
+        return undefined;
+    const cost = (inputTokens / 1_000_000) * pricing.inputPer1M +
+        (outputTokens / 1_000_000) * pricing.outputPer1M +
+        (cacheCreationTokens / 1_000_000) * pricing.cacheCreationPer1M +
+        (cacheReadTokens / 1_000_000) * pricing.cacheReadPer1M;
+    return Math.round(cost * 1_000_000) / 1_000_000; // 6 decimal places
+}
+/**
+ * Calculate the USD cost with separate 5-minute and 1-hour cache write rates.
+ *
+ * Use when the Anthropic API response includes the `cache_creation` sub-object
+ * with `ephemeral_5m_input_tokens` and `ephemeral_1h_input_tokens`.
+ *
+ * @returns Cost in USD, or `undefined` if the model is unknown.
+ */
+function calculateCostUsdExtended(model, inputTokens, outputTokens, cacheCreation5mTokens, cacheCreation1hTokens, cacheReadTokens) {
+    const pricing = exports.MODEL_PRICING_EXTENDED[model] ?? (() => {
+        // Fall back to base pricing with derived 1h rate (2x input).
+        const base = resolvePricing(model);
+        if (!base)
+            return undefined;
+        return {
+            ...base,
+            cacheCreation5mPer1M: base.cacheCreationPer1M,
+            cacheCreation1hPer1M: base.inputPer1M * 2,
+        };
+    })();
+    if (!pricing)
+        return undefined;
+    const ext = pricing;
+    const cost = (inputTokens / 1_000_000) * ext.inputPer1M +
+        (outputTokens / 1_000_000) * ext.outputPer1M +
+        (cacheCreation5mTokens / 1_000_000) * ext.cacheCreation5mPer1M +
+        (cacheCreation1hTokens / 1_000_000) * ext.cacheCreation1hPer1M +
+        (cacheReadTokens / 1_000_000) * ext.cacheReadPer1M;
+    return Math.round(cost * 1_000_000) / 1_000_000;
+}

package/dist/daemon/automationExecutor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared automation-rule execution path for daemon timer and webhook triggers.
+ */
+import type { AutomationExecutionRecord } from "@a5c-ai/agent-comm-mux";
+import type { AutomationTriggerEvent } from "./types";
+type StoredAutomationExecutionRecord = Omit<AutomationExecutionRecord, "status" | "reason"> & {
+    readonly status: AutomationExecutionRecord["status"] | "skipped";
+    readonly skipReason?: string;
+};
+export interface ExecuteAutomationTriggerOptions {
+    backlogFilePath?: string;
+    now?: () => string;
+}
+export declare function executeAutomationTrigger(event: AutomationTriggerEvent, options?: ExecuteAutomationTriggerOptions): Promise<StoredAutomationExecutionRecord>;
+export {};
+//# sourceMappingURL=automationExecutor.d.ts.map

package/dist/daemon/automationExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automationExecutor.d.ts","sourceRoot":"","sources":["../../src/daemon/automationExecutor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,KAAK,EACV,yBAAyB,EAY1B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AA8CtD,KAAK,+BAA+B,GAAG,IAAI,CAAC,yBAAyB,EAAE,QAAQ,GAAG,QAAQ,CAAC,GAAG;IAC5F,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;IACjE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AASF,MAAM,WAAW,+BAA+B;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AA4LD,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,sBAAsB,EAC7B,OAAO,GAAE,+BAAoC,GAC5C,OAAO,CAAC,+BAA+B,CAAC,CA4E1C"}

package/dist/daemon/automationExecutor.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * Shared automation-rule execution path for daemon timer and webhook triggers.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAutomationTrigger = executeAutomationTrigger;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const DEFAULT_BACKLOG_FILE_PATH = process.env.KANBAN_BACKLOG_FILE
+    ?? node_path_1.default.join(node_os_1.default.homedir(), ".a5c", "kanban-backlog.json");
+function cloneRecord(value) {
+    return value ? { ...value } : undefined;
+}
+async function readAutomationStorage(backlogFilePath) {
+    try {
+        const raw = await node_fs_1.promises.readFile(backlogFilePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const errno = error;
+        if (errno.code === "ENOENT") {
+            return {};
+        }
+        throw error;
+    }
+}
+async function writeAutomationStorage(backlogFilePath, payload) {
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(backlogFilePath), { recursive: true });
+    await node_fs_1.promises.writeFile(backlogFilePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+function createTriggerMetadata(rule) {
+    if (rule.trigger.type === "timer") {
+        return {
+            triggerType: "timer",
+            cron: rule.trigger.cron,
+            timezone: rule.trigger.timezone,
+        };
+    }
+    return {
+        triggerType: "webhook",
+        port: rule.trigger.port,
+        path: rule.trigger.path ?? "/trigger",
+        method: rule.trigger.method ?? "POST",
+        sourceEvent: rule.trigger.sourceEvent,
+    };
+}
+function nextIssueNumber(project, issues) {
+    const prefix = `${project.key}-AUTO-`;
+    return issues.reduce((max, issue) => {
+        if (!issue.key.startsWith(prefix)) {
+            return max;
+        }
+        const rawNumber = issue.key.slice(prefix.length);
+        const parsed = Number.parseInt(rawNumber, 10);
+        return Number.isFinite(parsed) ? Math.max(max, parsed) : max;
+    }, 0) + 1;
+}
+function resolveProjectCollections(project, template) {
+    const labelsById = new Map(project.labels.map((label) => [label.id, label]));
+    const assigneesById = new Map(project.assignees.map((assignee) => [assignee.id, assignee]));
+    return {
+        labels: (template.labelIds ?? [])
+            .map((labelId) => labelsById.get(labelId))
+            .filter((label) => Boolean(label)),
+        assignees: (template.assigneeIds ?? [])
+            .map((assigneeId) => assigneesById.get(assigneeId))
+            .filter((assignee) => Boolean(assignee)),
+    };
+}
+function resolveIssueSource(rule) {
+    if (rule.template.issueSource) {
+        return { ...rule.template.issueSource };
+    }
+    if (rule.source.kind === "config-file") {
+        return {
+            kind: "file",
+            path: rule.source.path,
+            externalId: rule.source.externalId ?? rule.id,
+        };
+    }
+    return {
+        kind: "run-derived",
+        externalId: rule.source.externalId ?? rule.id,
+    };
+}
+function createAcceptanceCriteria(issueId, criteria) {
+    return (criteria ?? []).map((title, index) => ({
+        id: `${issueId}-ac-${index + 1}`,
+        title,
+        satisfied: false,
+    }));
+}
+function createDecomposition(issueId, items) {
+    return (items ?? []).map((item, index) => ({
+        id: `${issueId}-decomp-${index + 1}`,
+        title: item.title,
+        kind: item.kind,
+        status: item.status,
+        issueId: undefined,
+    }));
+}
+function createAutomationIssue(rule, project, issues, now) {
+    const sequence = nextIssueNumber(project, issues);
+    const issueKey = `${project.key}-AUTO-${String(sequence).padStart(3, "0")}`;
+    const issueId = issueKey;
+    const { labels, assignees } = resolveProjectCollections(project, rule.template);
+    return {
+        id: issueId,
+        key: issueKey,
+        projectId: rule.target.projectId,
+        title: rule.template.title,
+        summary: rule.template.summary,
+        description: rule.template.description,
+        status: rule.template.status ?? "backlog",
+        priority: rule.template.priority ?? "medium",
+        labels,
+        assignees,
+        dependencies: [],
+        acceptanceCriteria: createAcceptanceCriteria(issueId, rule.template.acceptanceCriteria),
+        decomposition: createDecomposition(issueId, rule.template.decomposition),
+        childIssueIds: [],
+        createdAt: now,
+        updatedAt: now,
+        source: resolveIssueSource(rule),
+    };
+}
+function createExecutionRecord(rule, event, now, overrides) {
+    return {
+        id: `automation-exec-${(0, node_crypto_1.randomUUID)().toLowerCase()}`,
+        ruleId: rule.id,
+        ruleName: rule.name,
+        triggerType: rule.trigger.type,
+        status: overrides.status,
+        triggeredAt: now,
+        triggeredBy: `daemon-${rule.trigger.type}`,
+        source: {
+            ...rule.source,
+            metadata: cloneRecord(rule.source.metadata),
+        },
+        projectId: rule.target.projectId,
+        boardProjectId: rule.target.boardProjectId,
+        issueId: overrides.issue?.id,
+        issueKey: overrides.issue?.key,
+        issueSource: overrides.issue?.source,
+        stateAtExecution: rule.state,
+        skipReason: overrides.skipReason,
+        inputs: event.inputs ? { ...event.inputs } : undefined,
+        metadata: createTriggerMetadata(rule),
+    };
+}
+async function executeAutomationTrigger(event, options = {}) {
+    const backlogFilePath = options.backlogFilePath ?? DEFAULT_BACKLOG_FILE_PATH;
+    const now = options.now?.() ?? new Date().toISOString();
+    const storage = await readAutomationStorage(backlogFilePath);
+    const rules = [...(storage.automationRules ?? [])];
+    const rule = rules.find((candidate) => candidate.id === event.rule.id) ?? event.rule;
+    if (rule.state !== "active") {
+        const execution = createExecutionRecord(rule, event, now, {
+            status: "skipped",
+            skipReason: `Rule ${rule.id} is ${rule.state}.`,
+        });
+        await writeAutomationStorage(backlogFilePath, {
+            ...storage,
+            automationExecutions: [...(storage.automationExecutions ?? []), execution],
+        });
+        return execution;
+    }
+    const projects = [...(storage.projects ?? [])];
+    const issueProject = projects.find((candidate) => candidate.id === rule.target.projectId);
+    const boardProject = projects.find((candidate) => candidate.id === rule.target.boardProjectId);
+    if (!issueProject || !boardProject) {
+        const missingTarget = !issueProject
+            ? `Project ${rule.target.projectId}`
+            : `Board project ${rule.target.boardProjectId}`;
+        const execution = createExecutionRecord(rule, event, now, {
+            status: "skipped",
+            skipReason: `${missingTarget} not found.`,
+        });
+        await writeAutomationStorage(backlogFilePath, {
+            ...storage,
+            automationExecutions: [...(storage.automationExecutions ?? []), execution],
+        });
+        return execution;
+    }
+    const issues = [...(storage.issues ?? [])];
+    const issue = createAutomationIssue(rule, issueProject, issues, now);
+    const execution = createExecutionRecord(rule, event, now, {
+        status: "created",
+        issue,
+    });
+    const nextRules = rules.length > 0
+        ? rules.map((candidate) => (candidate.id === rule.id
+            ? {
+                ...candidate,
+                audit: {
+                    ...candidate.audit,
+                    lastTriggeredAt: now,
+                    lastTriggeredBy: execution.triggeredBy,
+                },
+            }
+            : candidate))
+        : storage.automationRules;
+    const nextProjects = projects.map((candidate) => (candidate.id === issueProject.id || candidate.id === boardProject.id
+        ? {
+            ...candidate,
+            issueIds: Array.from(new Set([...candidate.issueIds, issue.id])),
+        }
+        : candidate));
+    await writeAutomationStorage(backlogFilePath, {
+        ...storage,
+        projects: nextProjects,
+        issues: [...issues, issue],
+        automationRules: nextRules,
+        automationExecutions: [...(storage.automationExecutions ?? []), execution],
+    });
+    return execution;
+}

package/dist/daemon/config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GAP-REMOTE-001: Daemon Config — load/validate/write daemon configuration.
+ */
+import type { ApiResult } from "../api/runs";
+import type { DaemonConfig } from "./types";
+export declare function loadDaemonConfig(configPath: string): Promise<ApiResult<DaemonConfig>>;
+export declare function writeDaemonConfig(config: DaemonConfig, configPath: string): Promise<ApiResult<void>>;
+//# sourceMappingURL=config.d.ts.map

package/dist/daemon/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/daemon/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAkJ5C,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CA0BlC;AAED,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAgB1B"}

package/dist/daemon/config.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * GAP-REMOTE-001: Daemon Config — load/validate/write daemon configuration.
+ */
+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.loadDaemonConfig = loadDaemonConfig;
+exports.writeDaemonConfig = writeDaemonConfig;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const utils_1 = require("../api/utils");
+const VALID_TRIGGER_TYPES = new Set(["file", "webhook", "timer"]);
+const VALID_AUTOMATION_STATES = new Set(["draft", "active", "paused", "disabled", "archived"]);
+const DEFAULT_MAX_CONCURRENT_RUNS = 4;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUnknownArray(value) {
+    return Array.isArray(value);
+}
+function validateFileTrigger(raw, index) {
+    if (!isRecord(raw)) {
+        return `Trigger at index ${index} must be an object`;
+    }
+    if (raw.type !== "file") {
+        return `Invalid trigger type at index ${index}: ${String(raw.type)}. Must be one of: file, webhook, timer`;
+    }
+    if (typeof raw.processId !== "string" || !raw.processId) {
+        return `Missing processId at trigger index ${index}`;
+    }
+    if (typeof raw.entrypoint !== "string" || !raw.entrypoint) {
+        return `Missing entrypoint at trigger index ${index}`;
+    }
+    if (typeof raw.pattern !== "string" || !raw.pattern) {
+        return `Missing pattern at trigger index ${index}`;
+    }
+    return null;
+}
+function validateAutomationRule(raw, index) {
+    if (!isRecord(raw)) {
+        return `Trigger at index ${index} must be an object`;
+    }
+    if (typeof raw.id !== "string" || !raw.id) {
+        return `Missing automation rule id at trigger index ${index}`;
+    }
+    if (typeof raw.name !== "string" || !raw.name) {
+        return `Missing automation rule name at trigger index ${index}`;
+    }
+    if (typeof raw.state !== "string" || !VALID_AUTOMATION_STATES.has(raw.state)) {
+        return `Invalid automation state at trigger index ${index}: ${String(raw.state)}`;
+    }
+    const trigger = raw.trigger;
+    if (!isRecord(trigger) || typeof trigger.type !== "string" || !VALID_TRIGGER_TYPES.has(trigger.type)) {
+        return `Invalid automation trigger type at index ${index}: ${String(isRecord(trigger) ? trigger.type : trigger)}`;
+    }
+    if (trigger.type === "file") {
+        return `Automation rules do not support file triggers at index ${index}`;
+    }
+    if (trigger.type === "timer" && (typeof trigger.cron !== "string" || !trigger.cron)) {
+        return `Missing cron for timer automation at trigger index ${index}`;
+    }
+    if (trigger.type === "webhook") {
+        if (typeof trigger.port !== "number" || trigger.port <= 0) {
+            return `Missing port for webhook automation at trigger index ${index}`;
+        }
+        if (trigger.path !== undefined && (typeof trigger.path !== "string" || !trigger.path)) {
+            return `Invalid webhook path at trigger index ${index}`;
+        }
+    }
+    const target = raw.target;
+    if (!isRecord(target) || typeof target.projectId !== "string" || !target.projectId) {
+        return `Missing target.projectId at trigger index ${index}`;
+    }
+    if (typeof target.boardProjectId !== "string" || !target.boardProjectId) {
+        return `Missing target.boardProjectId at trigger index ${index}`;
+    }
+    const template = raw.template;
+    if (!isRecord(template) || typeof template.title !== "string" || !template.title) {
+        return `Missing template.title at trigger index ${index}`;
+    }
+    const routing = raw.routing;
+    if (!isRecord(routing)) {
+        return `Missing routing block at trigger index ${index}`;
+    }
+    if (!isRecord(routing.issue) || routing.issue.action !== "canonical-issue-create") {
+        return `Invalid routing.issue action at trigger index ${index}`;
+    }
+    if (!isRecord(routing.board) || routing.board.action !== "shared-board-derive") {
+        return `Invalid routing.board action at trigger index ${index}`;
+    }
+    if (routing.mutateBoardDirectly !== false) {
+        return `Automation routing must disable direct board mutation at trigger index ${index}`;
+    }
+    const source = raw.source;
+    if (!isRecord(source) || typeof source.kind !== "string" || !source.kind) {
+        return `Missing source.kind at trigger index ${index}`;
+    }
+    const audit = raw.audit;
+    if (!isRecord(audit) || typeof audit.createdAt !== "string" || !audit.createdAt) {
+        return `Missing audit.createdAt at trigger index ${index}`;
+    }
+    return null;
+}
+function validateConfig(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return { valid: false, error: "Config must be a JSON object" };
+    }
+    const obj = raw;
+    if (typeof obj.workspace !== "string" || !obj.workspace) {
+        return { valid: false, error: "Missing required field: workspace" };
+    }
+    if (!isUnknownArray(obj.triggers)) {
+        return { valid: false, error: "Missing required field: triggers (must be an array)" };
+    }
+    for (let i = 0; i < obj.triggers.length; i++) {
+        const trigger = obj.triggers[i];
+        const error = isRecord(trigger) && trigger.type === "file"
+            ? validateFileTrigger(trigger, i)
+            : validateAutomationRule(trigger, i);
+        if (error) {
+            return { valid: false, error };
+        }
+    }
+    const maxConcurrent = typeof obj.maxConcurrentRuns === "number"
+        ? obj.maxConcurrentRuns
+        : DEFAULT_MAX_CONCURRENT_RUNS;
+    return {
+        valid: true,
+        config: {
+            workspace: obj.workspace,
+            triggers: obj.triggers,
+            maxConcurrentRuns: maxConcurrent,
+        },
+    };
+}
+async function loadDaemonConfig(configPath) {
+    try {
+        let raw;
+        try {
+            raw = await node_fs_1.promises.readFile(configPath, "utf-8");
+        }
+        catch {
+            return (0, utils_1.fail)("CONFIG_NOT_FOUND", `Config file not found: ${configPath}`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return (0, utils_1.fail)("INVALID_CONFIG", `Failed to parse config as JSON: ${configPath}`);
+        }
+        const result = validateConfig(parsed);
+        if (!result.valid) {
+            return (0, utils_1.fail)("INVALID_CONFIG", result.error);
+        }
+        return (0, utils_1.ok)(result.config);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}
+async function writeDaemonConfig(config, configPath) {
+    try {
+        const dir = path.dirname(configPath);
+        await node_fs_1.promises.mkdir(dir, { recursive: true });
+        const content = JSON.stringify(config, null, 2);
+        const tmpPath = `${configPath}.tmp-${process.pid}-${Date.now()}`;
+        await node_fs_1.promises.writeFile(tmpPath, content, "utf-8");
+        await node_fs_1.promises.rename(tmpPath, configPath);
+        return (0, utils_1.ok)(undefined);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (0, utils_1.fail)("INTERNAL_ERROR", msg);
+    }
+}