@kafca/agentdock 0.1.58 → 0.1.62

package/dist-electron/services/local-ai-core/src/thread/agent-message-policy.js

@@ -49,7 +49,7 @@ const CHANNEL_INSTRUCTION = [
     'Only use the channel CLI when the user explicitly asks to send a file through the channel.',
     '[/Channel Tools]',
 ].join('\n');
-function composeAgentMessage(content, knowledgeBases = []) {
+function composeAgentMessage(content, knowledgeBases = [], catalog = new managed_skill_catalog_js_1.ManagedSkillCatalog()) {
     if (content.trim().startsWith('/')) {
         return content;
     }
@@ -60,12 +60,15 @@ function composeAgentMessage(content, knowledgeBases = []) {
             '[/Selected Knowledge Bases]',
         ].join('\n')
         : '';
+    const conditionSkill = isConditionAutomationRequest(content) ? catalog.get('condition-trigger')?.content || '' : '';
+    const conditionHelper = conditionSkill ? catalog.getHelperPath('condition-trigger', 'scripts/register-condition-trigger.sh') || '' : '';
     return [
         SCHEDULER_INSTRUCTION,
         '',
         MONITOR_INSTRUCTION,
         '',
         CHANNEL_INSTRUCTION,
+        ...(conditionSkill ? ['', '[Condition Trigger Skill]', conditionSkill, '[/Condition Trigger Skill]', '[Condition Trigger Helper]', conditionHelper, '[/Condition Trigger Helper]'] : []),
         ...(knowledgeBlock ? ['', knowledgeBlock] : []),
         '',
         '[User Message]',
@@ -73,3 +76,15 @@ function composeAgentMessage(content, knowledgeBases = []) {
         '[/User Message]',
     ].join('\n');
 }
+function isConditionAutomationRequest(content) {
+    const normalized = content.toLowerCase();
+    const englishCondition = /\b(?:condition(?:al)?|script[-\s]?(?:based|backed)?)\b/.test(normalized);
+    const englishAutomation = /\b(?:automation|monitor|task|schedule)\b/.test(normalized);
+    const englishRequest = /\b(?:create|add|set(?:\s+up)?|configure|build|author)\b/.test(normalized);
+    const englishNegation = /\b(?:do not|don't|dont|never|without).{0,24}\b(?:create|add|set(?:\s+up)?|configure|build|author)\b/.test(normalized);
+    const chineseCondition = /条件自动化|条件触发|脚本条件/.test(content);
+    const chineseRequest = /创建|新建|设置|添加|建立|配置|制作|实现/.test(content);
+    const chineseNegation = /(?:不要|不需要|无需|别|仅|只是|不想).{0,8}(?:创建|新建|设置|添加|建立|配置|制作|实现)/.test(content);
+    return (englishCondition && englishAutomation && englishRequest && !englishNegation) || (chineseCondition && chineseRequest && !chineseNegation);
+}
+const managed_skill_catalog_js_1 = require("../runtime/managed-skill-catalog.js");

package/dist-electron/src/pages/Automation/automation-page-model.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveAutomationDisplayStatus = deriveAutomationDisplayStatus;
+exports.filterAutomationRows = filterAutomationRows;
+exports.approvalActionForVersion = approvalActionForVersion;
+exports.approvalResolutionForVersion = approvalResolutionForVersion;
+exports.formatEvaluation = formatEvaluation;
+exports.formatRun = formatRun;
+exports.redactSecretName = redactSecretName;
+exports.originLabel = originLabel;
+function deriveAutomationDisplayStatus(automation) {
+    if (automation.health === 'blocked')
+        return 'blocked';
+    return automation.enabled ? 'active' : 'paused';
+}
+function filterAutomationRows(automations, filter = {}) {
+    const query = filter.query?.trim().toLocaleLowerCase() || '';
+    return automations.filter((automation) => {
+        const origin = automation.originKind || 'native';
+        return (!filter.origin || filter.origin === 'all' || origin === filter.origin) &&
+            (!query || `${automation.title} ${automation.workspaceId}`.toLocaleLowerCase().includes(query));
+    });
+}
+/** The API exposes pending IDs only for transitions the server currently authorizes. */
+function approvalActionForVersion(version) {
+    switch (version.status) {
+        case 'pending_test_approval': return version.pendingTestApprovalId ? 'authorize-test' : null;
+        case 'test_authorized': return 'run-test';
+        case 'tested': return 'request-enable';
+        case 'pending_approval': return version.pendingApprovalId ? 'approve-enable' : null;
+        case 'approved': return 'revoke';
+        default: return null;
+    }
+}
+/**
+ * An Automation version endpoint applies a decision; it never makes one. Keep
+ * the pending ID selected by the server and resolve that ApprovalRequest first.
+ */
+function approvalResolutionForVersion(version, decision) {
+    const approvalId = version.status === 'pending_test_approval'
+        ? version.pendingTestApprovalId
+        : version.status === 'pending_approval'
+            ? version.pendingApprovalId
+            : undefined;
+    return approvalId ? { approvalId, decision } : null;
+}
+function formatEvaluation(evaluation) {
+    if (!evaluation)
+        return '—';
+    if (evaluation.status === 'running')
+        return 'Running';
+    if (evaluation.errorCategory === 'sandbox_unavailable')
+        return 'Blocked: sandbox unavailable';
+    if (evaluation.conditionOutcome === 'error')
+        return `Error${evaluation.errorCategory ? `: ${evaluation.errorCategory}` : ''}`;
+    return `${evaluation.conditionOutcome || 'finished'} · ${evaluation.triggerDecision || 'not evaluated'}`;
+}
+function formatRun(run) {
+    if (!run)
+        return '—';
+    return `${run.status}${run.deliveryStatus ? ` · ${run.deliveryStatus}` : ''}`;
+}
+/** Never expose full secret names in list/detail views. */
+function redactSecretName(reference) {
+    const name = reference.replace(/^env:\/\//, '').trim();
+    if (name.length < 7)
+        return '***';
+    return `${name.slice(0, 4)}…${name.slice(-4)}`;
+}
+function originLabel(origin) {
+    if (origin === 'scheduled-job')
+        return 'Cron';
+    if (origin === 'automation-monitor')
+        return 'Monitor';
+    return 'Native';
+}

package/dist-electron/tests/contracts/agent-message-policy.test.js

@@ -6,6 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_test_1 = __importDefault(require("node:test"));
 const strict_1 = __importDefault(require("node:assert/strict"));
 const agent_message_policy_js_1 = require("../../services/local-ai-core/src/thread/agent-message-policy.js");
+const managed_skill_catalog_js_1 = require("../../services/local-ai-core/src/runtime/managed-skill-catalog.js");
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
 (0, node_test_1.default)('agent message policy is owned by Local Core and includes selected knowledge context', () => {
     const message = (0, agent_message_policy_js_1.composeAgentMessage)('Summarize the design', [
         { id: 'kb-1', name: 'Architecture notes' },
@@ -19,3 +22,32 @@ const agent_message_policy_js_1 = require("../../services/local-ai-core/src/thre
 (0, node_test_1.default)('agent message policy leaves slash commands untouched', () => {
     strict_1.default.equal((0, agent_message_policy_js_1.composeAgentMessage)('/agent use pi'), '/agent use pi');
 });
+(0, node_test_1.default)('agent message policy injects the exact managed condition trigger skill only for condition automations', () => {
+    const catalog = new managed_skill_catalog_js_1.ManagedSkillCatalog({ rootDir: (0, node_path_1.join)(process.cwd(), 'electron', 'managed-skills') });
+    const skill = catalog.get('condition-trigger');
+    (0, strict_1.default)(skill);
+    const matching = (0, agent_message_policy_js_1.composeAgentMessage)('Create an automation when a script condition matches.', [], catalog);
+    strict_1.default.match(matching, new RegExp(escapeRegex(skill.content)));
+    const nonMatching = (0, agent_message_policy_js_1.composeAgentMessage)('Schedule a reminder every day at noon.', [], catalog);
+    strict_1.default.doesNotMatch(nonMatching, /\[Condition Trigger Skill\]/);
+});
+(0, node_test_1.default)('condition trigger skill is injected for explicit Chinese condition automation requests, not generic trigger words', () => {
+    const catalog = new managed_skill_catalog_js_1.ManagedSkillCatalog({ rootDir: (0, node_path_1.join)(process.cwd(), 'electron', 'managed-skills') });
+    for (const message of ['创建一个条件自动化，在脚本条件满足时触发', '请设置条件触发任务', '为这个脚本条件创建自动化']) {
+        strict_1.default.match((0, agent_message_policy_js_1.composeAgentMessage)(message, [], catalog), /\[Condition Trigger Skill\]/);
+    }
+    for (const message of ['触发一次普通任务', 'Please trigger a response now.', '解释条件自动化的概念，但不要创建它', 'Do not create a condition automation.', '我不想创建条件自动化']) {
+        strict_1.default.doesNotMatch((0, agent_message_policy_js_1.composeAgentMessage)(message, [], catalog), /\[Condition Trigger Skill\]/);
+    }
+});
+(0, node_test_1.default)('condition helper path is catalog-owned and remains valid outside the repository cwd', () => {
+    const catalog = new managed_skill_catalog_js_1.ManagedSkillCatalog({ rootDir: (0, node_path_1.join)(process.cwd(), 'electron', 'managed-skills') });
+    const helperPath = catalog.getHelperPath('condition-trigger', 'scripts/register-condition-trigger.sh');
+    (0, strict_1.default)(helperPath);
+    const message = (0, agent_message_policy_js_1.composeAgentMessage)('Create a script condition automation.', [], catalog);
+    strict_1.default.match(message, new RegExp(`\\[Condition Trigger Helper\\]\\n${escapeRegex(helperPath)}`));
+    strict_1.default.equal((0, node_fs_1.existsSync)(helperPath), true);
+});
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist-electron/tests/contracts/architecture-docs.test.js

@@ -161,3 +161,33 @@ function readSourceFiles(scope) {
         strict_1.default.match(highlighted, new RegExp(`highlight\\.js/lib/languages/${language}`), `${language} must remain in the supported subset`);
     }
 });
+(0, node_test_1.default)('conditional automation architecture documents its security and ownership invariants', () => {
+    const content = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'docs', 'architecture', 'conditional-automation.md'), 'utf8');
+    for (const invariant of [
+        'Activation → Condition → Action → Delivery',
+        'immutable package',
+        'two-stage approval',
+        'previousState',
+        'public egress',
+        'private-address deny',
+        'Windows fail-closed',
+        '30 days',
+        '1000',
+        'legacy Scheduler and Monitor facades',
+        'DNS rebinding',
+        'detached process',
+    ]) {
+        strict_1.default.match(content, new RegExp(invariant, 'i'), `conditional automation docs must cover ${invariant}`);
+    }
+    strict_1.default.match(content, /macOS[^\n]+Linux|Linux[^\n]+macOS/i);
+});
+(0, node_test_1.default)('deployment docs require a dedicated AppArmor profile without weakening the global userns policy', () => {
+    const content = (0, node_fs_1.readFileSync)((0, node_path_1.join)(rootDir, 'docs', 'operations', 'release-workflow.md'), 'utf8');
+    strict_1.default.match(content, /Ubuntu 24\.04\+/);
+    strict_1.default.match(content, /dedicated AppArmor profile/i);
+    strict_1.default.match(content, /kernel\.apparmor_restrict_unprivileged_userns/);
+    strict_1.default.match(content, /must not|do not|禁止/i);
+    strict_1.default.match(content, /behaviorally executes|behavioral/i);
+    strict_1.default.match(content, /sysctl is only failure-classification context/i);
+    strict_1.default.doesNotMatch(content, /sysctl\s+-w\s+kernel\.apparmor_restrict_unprivileged_userns=0/);
+});

package/dist-electron/tests/contracts/automation-contracts.test.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const automations_js_1 = require("../../packages/contracts/src/automations.js");
+const evaluationCreateInput = {
+    activationKind: 'cron',
+    startedAt: '2026-07-05T00:00:00.000Z',
+};
+const runningEvaluation = {
+    id: 'evaluation:1',
+    automationId: 'automation:1',
+    status: 'running',
+    activationKind: 'cron',
+    startedAt: '2026-07-05T00:00:00.000Z',
+};
+const evaluationFinishInput = {
+    conditionOutcome: 'error',
+    triggerDecision: 'not_evaluated',
+    finishedAt: '2026-07-05T00:00:01.000Z',
+};
+const concurrentSkipFinishInput = {
+    conditionOutcome: 'skipped',
+    triggerDecision: 'skipped_concurrent',
+    finishedAt: '2026-07-05T00:00:01.000Z',
+};
+const closedRunMode = 'same-thread';
+void evaluationCreateInput;
+void runningEvaluation;
+void evaluationFinishInput;
+void concurrentSkipFinishInput;
+void closedRunMode;
+function definition(overrides = {}) {
+    return {
+        id: 'automation:1',
+        workspaceId: 'ws',
+        title: 'Check API',
+        enabled: true,
+        health: 'healthy',
+        activation: { kind: 'cron', expression: '*/5 * * * *', timezone: 'Asia/Shanghai' },
+        condition: {
+            kind: 'approved-script',
+            scriptId: 'script:1',
+            approvedVersionId: 'version:1',
+            edge: 'rising',
+        },
+        action: {
+            kind: 'agent-prompt',
+            promptTemplate: 'analyze {{summary}}',
+            executionMode: 'side-thread',
+        },
+        delivery: {
+            platform: 'local',
+            route: { type: 'local.thread', channelId: 'ws' },
+        },
+        policies: { concurrency: 'skip-if-running', cooldownMs: 0 },
+        consecutiveEvaluationFailures: 0,
+        createdAt: '2026-07-05T00:00:00.000Z',
+        updatedAt: '2026-07-05T00:00:00.000Z',
+        ...overrides,
+    };
+}
+(0, node_test_1.default)('normalizes an automation with an approved-script condition', () => {
+    const result = (0, automations_js_1.normalizeAutomationDefinition)(definition());
+    strict_1.default.equal(result.condition.kind, 'approved-script');
+});
+(0, node_test_1.default)('keeps truthful condition outcomes separate from trigger decisions', () => {
+    strict_1.default.deepEqual([evaluationFinishInput, concurrentSkipFinishInput].map(({ conditionOutcome, triggerDecision }) => ({
+        conditionOutcome,
+        triggerDecision,
+    })), [
+        { conditionOutcome: 'error', triggerDecision: 'not_evaluated' },
+        { conditionOutcome: 'skipped', triggerDecision: 'skipped_concurrent' },
+    ]);
+});
+(0, node_test_1.default)('normalizes every activation discriminator', () => {
+    const cases = [
+        { input: { kind: 'cron', expression: '0 * * * *', timezone: 'UTC' }, kind: 'cron' },
+        { input: { kind: 'once', runAt: '2026-07-05T00:00:00.000Z' }, kind: 'once' },
+        { input: { kind: 'interval', intervalMs: 1 }, kind: 'interval' },
+        { input: { kind: 'provider-event', sourceType: 'stock.quote', sourceConfig: {} }, kind: 'provider-event' },
+    ];
+    for (const entry of cases) {
+        strict_1.default.equal((0, automations_js_1.normalizeAutomationActivation)(entry.input).kind, entry.kind);
+    }
+});
+(0, node_test_1.default)('normalizes every condition discriminator', () => {
+    const cases = [
+        { input: { kind: 'always' }, kind: 'always' },
+        { input: { kind: 'expression', expression: 'price > 10' }, kind: 'expression' },
+        {
+            input: { kind: 'approved-script', scriptId: 'script:1', approvedVersionId: 'version:1', edge: 'rising' },
+            kind: 'approved-script',
+        },
+    ];
+    for (const entry of cases) {
+        strict_1.default.equal((0, automations_js_1.normalizeAutomationCondition)(entry.input).kind, entry.kind);
+    }
+});
+(0, node_test_1.default)('rejects invalid activation and condition variants', () => {
+    const invalidActivations = [
+        { kind: 'unknown' },
+        { kind: 'cron', expression: '', timezone: 'UTC' },
+        { kind: 'once', runAt: 'tomorrow' },
+        { kind: 'interval', intervalMs: 0 },
+        { kind: 'interval', intervalMs: -1 },
+        { kind: 'interval', intervalMs: 1.5 },
+        { kind: 'provider-event', sourceType: 'stock.quote', sourceConfig: [] },
+    ];
+    const invalidConditions = [
+        { kind: 'unknown' },
+        { kind: 'expression', expression: '' },
+        { kind: 'approved-script', scriptId: 'script:1', approvedVersionId: 'version:1', edge: 'falling' },
+    ];
+    for (const input of invalidActivations)
+        strict_1.default.throws(() => (0, automations_js_1.normalizeAutomationActivation)(input));
+    for (const input of invalidConditions)
+        strict_1.default.throws(() => (0, automations_js_1.normalizeAutomationCondition)(input));
+});
+(0, node_test_1.default)('rejects malformed routes and invalid numeric bounds', () => {
+    const cases = [
+        definition({ delivery: { platform: 'local', route: { type: 'local.thread' } } }),
+        definition({ delivery: { platform: 'local', route: { type: '', channelId: 'ws' } } }),
+        definition({ policies: { concurrency: 'skip-if-running', cooldownMs: -1 } }),
+        definition({ consecutiveEvaluationFailures: 1.5 }),
+    ];
+    for (const input of cases)
+        strict_1.default.throws(() => (0, automations_js_1.normalizeAutomationDefinition)(input));
+});
+(0, node_test_1.default)('rejects falsy and non-string execution modes while preserving string aliases', () => {
+    for (const executionMode of [undefined, null, '', '   ', false, 0]) {
+        strict_1.default.throws(() => (0, automations_js_1.normalizeAutomationDefinition)(definition({
+            action: { kind: 'agent-prompt', promptTemplate: 'analyze', executionMode },
+        })), /executionMode/);
+    }
+    const normalized = (0, automations_js_1.normalizeAutomationDefinition)(definition({
+        action: { kind: 'agent-prompt', promptTemplate: 'analyze', executionMode: 'SIDE THREAD' },
+    }));
+    strict_1.default.equal(normalized.action.executionMode, 'side-thread');
+});
+(0, node_test_1.default)('validates canonical timestamps', () => {
+    const invalidDefinitions = [
+        definition({ createdAt: 'today' }),
+        definition({ updatedAt: '2026-07-05' }),
+        definition({ lastEvaluationAt: 'not-a-date' }),
+        definition({ lastTriggeredAt: '2026-13-05T00:00:00.000Z' }),
+    ];
+    for (const input of invalidDefinitions)
+        strict_1.default.throws(() => (0, automations_js_1.normalizeAutomationDefinition)(input), /timestamp/);
+    strict_1.default.throws(() => (0, automations_js_1.normalizeAutomationActivation)({ kind: 'once', runAt: '2026-07-05' }), /timestamp/);
+});

package/dist-electron/tests/contracts/automation-renderer-model.test.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const automation_page_model_js_1 = require("../../src/pages/Automation/automation-page-model.js");
+const base = {
+    id: 'automation:1', workspaceId: 'workspace:1', title: 'Check API', enabled: true,
+    health: 'healthy', activation: { kind: 'cron', expression: '*/5 * * * *', timezone: 'UTC' },
+    condition: { kind: 'always' }, action: { kind: 'agent-prompt', promptTemplate: 'check', executionMode: 'side-thread' },
+    delivery: { platform: 'local', route: { type: 'local.thread', channelId: 'workspace:1' } },
+    policies: { concurrency: 'skip-if-running', cooldownMs: 0 }, consecutiveEvaluationFailures: 0,
+    createdAt: '2026-07-12T00:00:00.000Z', updatedAt: '2026-07-12T00:00:00.000Z',
+};
+(0, node_test_1.default)('derives active, paused, and blocked display states without client-side transitions', () => {
+    strict_1.default.equal((0, automation_page_model_js_1.deriveAutomationDisplayStatus)(base), 'active');
+    strict_1.default.equal((0, automation_page_model_js_1.deriveAutomationDisplayStatus)({ ...base, enabled: false }), 'paused');
+    strict_1.default.equal((0, automation_page_model_js_1.deriveAutomationDisplayStatus)({ ...base, health: 'blocked' }), 'blocked');
+});
+(0, node_test_1.default)('renders only server-authorized script approval actions for every stage', () => {
+    const statuses = ['draft', 'pending_test_approval', 'test_authorized', 'testing', 'tested', 'pending_approval', 'approved', 'rejected', 'revoked'];
+    strict_1.default.deepEqual(statuses.map((status) => (0, automation_page_model_js_1.approvalActionForVersion)({ status, pendingTestApprovalId: 'test', pendingApprovalId: 'enable' })), [
+        null, 'authorize-test', 'run-test', null, 'request-enable', 'approve-enable', 'revoke', null, null,
+    ]);
+});
+(0, node_test_1.default)('requires resolving the server-issued pending approval before applying a script decision', () => {
+    strict_1.default.deepEqual((0, automation_page_model_js_1.approvalResolutionForVersion)({ status: 'pending_test_approval', pendingTestApprovalId: 'test:1' }, 'approved'), { approvalId: 'test:1', decision: 'approved' });
+    strict_1.default.deepEqual((0, automation_page_model_js_1.approvalResolutionForVersion)({ status: 'pending_approval', pendingApprovalId: 'enable:1' }, 'rejected'), { approvalId: 'enable:1', decision: 'rejected' });
+    strict_1.default.equal((0, automation_page_model_js_1.approvalResolutionForVersion)({ status: 'tested' }, 'approved'), null);
+});
+(0, node_test_1.default)('groups and filters legacy origins and presents evaluations/runs safely', () => {
+    const rows = (0, automation_page_model_js_1.filterAutomationRows)([
+        { ...base, id: 'native', originKind: 'native' },
+        { ...base, id: 'cron', originKind: 'scheduled-job' },
+        { ...base, id: 'monitor', originKind: 'automation-monitor' },
+    ], { origin: 'scheduled-job', query: 'api' });
+    strict_1.default.deepEqual(rows.map((row) => row.id), ['cron']);
+    strict_1.default.equal((0, automation_page_model_js_1.originLabel)('automation-monitor'), 'Monitor');
+    strict_1.default.match((0, automation_page_model_js_1.formatEvaluation)({ status: 'finished', conditionOutcome: 'error', triggerDecision: 'not_evaluated', errorCategory: 'sandbox_unavailable' }), /sandbox unavailable/i);
+    strict_1.default.match((0, automation_page_model_js_1.formatRun)({ status: 'failed' }), /failed/i);
+});
+(0, node_test_1.default)('redacts secret names while retaining a useful identifier', () => {
+    strict_1.default.equal((0, automation_page_model_js_1.redactSecretName)('env://PROVIDER_API_TOKEN'), 'PROV…OKEN');
+    strict_1.default.equal((0, automation_page_model_js_1.redactSecretName)('env://KEY'), '***');
+});

package/dist-electron/tests/electron/automation-action-executor.test.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const automation_action_executor_js_1 = require("../../services/local-ai-core/src/automation/automation-action-executor.js");
+function definition(platform = 'lark') {
+    return {
+        id: 'automation-1',
+        workspaceId: 'workspace-1',
+        title: 'Safe prompt',
+        enabled: true,
+        health: 'healthy',
+        activation: { kind: 'once', runAt: '2026-07-05T08:00:00.000Z' },
+        condition: { kind: 'always' },
+        action: { kind: 'agent-prompt', promptTemplate: 'run', executionMode: 'side-thread' },
+        delivery: { platform, route: { type: 'channel.chat', channelId: 'chat-1' } },
+        policies: { concurrency: 'skip-if-running', cooldownMs: 0 },
+        consecutiveEvaluationFailures: 0,
+        createdAt: '2026-07-05T07:00:00.000Z',
+        updatedAt: '2026-07-05T07:00:00.000Z',
+        originKind: 'native',
+    };
+}
+const evaluation = {
+    id: 'evaluation-1',
+    automationId: 'automation-1',
+    status: 'finished',
+    activationKind: 'once',
+    startedAt: '2026-07-05T08:00:00.000Z',
+    finishedAt: '2026-07-05T08:00:00.000Z',
+    conditionOutcome: 'matched',
+    triggerDecision: 'triggered',
+};
+(0, node_test_1.default)('prompt rendering uses only own data properties and safely serializes objects', () => {
+    const circular = {};
+    circular.self = circular;
+    const inherited = Object.create({ constructor: 'unsafe', toString: 'unsafe', prototype: 'unsafe' });
+    Object.defineProperty(inherited, 'constructor', { enumerable: true, value: 'also unsafe' });
+    const object = Object.create({ toJSON: () => { throw new Error('must not run'); } });
+    object.value = 42;
+    Object.defineProperty(object, 'nestedGetter', { enumerable: true, get: () => { throw new Error('must not run'); } });
+    inherited.object = object;
+    inherited.circular = circular;
+    Object.defineProperty(inherited, 'getter', { enumerable: true, get: () => { throw new Error('must not run'); } });
+    strict_1.default.equal((0, automation_action_executor_js_1.renderAutomationPrompt)('{{constructor}}|{{toString}}|{{prototype}}|{{getter}}|{{object}}|{{circular}}', inherited), '||||{"value":42}|[Unserializable]');
+});
+(0, node_test_1.default)('action executor closes an opened bridge when ACP send fails', async () => {
+    let closed = false;
+    const executor = new automation_action_executor_js_1.AutomationActionExecutor({
+        store: {
+            getPlatformThreadBinding: () => undefined,
+            getRun: () => ({ status: 'completed' }),
+        },
+        getWorkspaceRouter: () => ({
+            listThreads: async () => [],
+            createThread: async () => ({ id: 'thread-1' }),
+            getThreadSessionKey: () => 'session-1',
+            sendThreadMessage: async () => { throw new Error('send failed'); },
+        }),
+        getChannelRuntime: () => ({
+            platform: 'lark',
+            registerScheduledThreadBridge: async () => () => { closed = true; },
+            onBridgeEvent: async () => undefined,
+        }),
+    });
+    await strict_1.default.rejects(() => executor.execute({
+        automation: definition(),
+        evaluation,
+        promptVariables: {},
+    }), /send failed/);
+    strict_1.default.equal(closed, true);
+});