macroclaw 0.34.0 → 0.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "macroclaw",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "Telegram-to-Claude-Code bridge",
   "license": "MIT",
   "type": "module",
@@ -32,6 +32,7 @@
     "citty": "^0.2.1",
     "cron-parser": "^5.5.0",
     "grammy": "^1.39.3",
+    "luxon": "^3.7.2",
     "openai": "^6.27.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
@@ -41,6 +42,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.6",
+    "@types/luxon": "^3.7.1",
     "bun-types": "^1.3.10",
     "dependency-cruiser": "^17.3.8",
     "typescript": "^5.9.3"

package/src/app.test.ts

@@ -132,6 +132,8 @@ function makeConfig(overrides?: Partial<AppConfig>): AppConfig {
     botToken: "test-token",
     authorizedChatId: "12345",
     workspace: "/tmp/macroclaw-test-workspace",
+    model: "sonnet",
+    timezone: "UTC",
     settingsDir: tmpSettingsDir,
     claude: defaultMockClaude(),
     stt: mockStt(),

package/src/app.ts

@@ -11,7 +11,8 @@ export interface AppConfig {
   botToken: string;
   authorizedChatId: string;
   workspace: string;
-  model?: string;
+  model: string;
+  timezone: string;
   settingsDir?: string;
   claude?: Claude;
   stt?: SpeechToText;
@@ -29,6 +30,7 @@ export class App {
     this.#orchestrator = new Orchestrator({
       model: config.model,
       workspace: config.workspace,
+      timezone: config.timezone,
       settingsDir: config.settingsDir,
       claude: config.claude,
       healthCheckInterval: config.healthCheckInterval,
@@ -49,6 +51,7 @@ export class App {
   start() {
     log.info("Starting macroclaw...");
     const scheduler = new Scheduler(this.#config.workspace, {
+      timezone: this.#config.timezone,
       onJob: (name, prompt, model, missed) => this.#orchestrator.handleCron(name, prompt, model, missed),
     });
     scheduler.start();

package/src/claude.test.ts

@@ -491,5 +491,13 @@ describe("Claude factory", () => {
       expect(opts.stdout).toBe("pipe");
       expect(opts.stderr).toBe("pipe");
     });
+
+    it("merges envVars into the process environment", () => {
+      mockSpawn();
+      const claude = new Claude({ workspace: TEST_WORKSPACE, envVars: { TZ: "Europe/Prague" } });
+      claude.newSession(textResult);
+      const opts = spawnOpts();
+      expect((opts.env as Record<string, string>).TZ).toBe("Europe/Prague");
+    });
   });
 });

package/src/claude.ts

@@ -18,6 +18,8 @@ export interface ClaudeConfig {
   workspace: string;
   model?: string;
   systemPrompt?: string;
+  /** Extra environment variables to set when spawning the Claude process */
+  envVars?: Record<string, string>;
 }
 
 /** Per-call overrides */
@@ -221,11 +223,13 @@ export class Claude {
   readonly #workspace: string;
   readonly #model?: string;
   readonly #systemPrompt?: string;
+  readonly #envVars: Record<string, string>;
 
   constructor(config: ClaudeConfig) {
     this.#workspace = config.workspace;
     this.#model = config.model;
     this.#systemPrompt = config.systemPrompt;
+    this.#envVars = config.envVars ?? {};
   }
 
   newSession<R extends ResultType>(resultType: R, options?: QueryOptions): ClaudeProcess<InferResult<R>> {
@@ -241,7 +245,7 @@ export class Claude {
   }
 
   #spawn<R extends ResultType>(mode: SessionMode, resultType: R, options?: QueryOptions): ClaudeProcess<InferResult<R>> {
-    const env = { ...process.env };
+    const env = { ...process.env, ...this.#envVars };
     delete env.CLAUDECODE;
 
     const model = options?.model ?? this.#model;

package/src/cli.test.ts

@@ -133,6 +133,7 @@ function mockService(overrides?: Record<string, unknown>): SystemServiceManager
 		uninstall: mock(() => {}),
 		start: mock(() => ""),
 		stop: mock(() => {}),
+		restart: mock(() => ""),
 		update: mock(() => ({ previousVersion: "0.6.0", currentVersion: "0.7.0" })),
 		isRunning: false,
 		status: mock(() => ({ installed: false, running: false, platform: "systemd" as const })),
@@ -170,6 +171,13 @@ describe("Cli.service", () => {
 		expect(stop).toHaveBeenCalled();
 	});
 
+	it("runs restart action", () => {
+		const restart = mock(() => "tail -f /logs");
+		const cli = new Cli({ systemService: mockService({ restart }) });
+		cli.service("restart");
+		expect(restart).toHaveBeenCalled();
+	});
+
 	it("runs update action — stops and starts when running", () => {
 		const stop = mock(() => {});
 		const start = mock(() => "tail -f /logs");

package/src/cli.ts

@@ -75,6 +75,11 @@ export class Cli {
 				console.log(`Service started. Check logs:\n  ${logCmd}`);
 				break;
 			}
+			case "restart": {
+				const logCmd = this.#serviceManager.restart();
+				console.log(`Service restarted. Check logs:\n  ${logCmd}`);
+				break;
+			}
 			case "status": {
 				const s = this.#serviceManager.status();
 				const lines = [
@@ -173,6 +178,11 @@ const serviceStatusCommand = defineCommand({
 	run: () => { try { defaultCli.service("status"); } catch (err) { handleError(err); } },
 });
 
+const serviceRestartCommand = defineCommand({
+	meta: { name: "restart", description: "Restart the service" },
+	run: () => { try { defaultCli.service("restart"); } catch (err) { handleError(err); } },
+});
+
 const serviceLogsCommand = defineCommand({
 	meta: { name: "logs", description: "Print the command to view service logs" },
 	args: {
@@ -188,6 +198,7 @@ const serviceCommand = defineCommand({
 		uninstall: serviceUninstallCommand,
 		start: serviceStartCommand,
 		stop: serviceStopCommand,
+		restart: serviceRestartCommand,
 		update: serviceUpdateCommand,
 		status: serviceStatusCommand,
 		logs: serviceLogsCommand,

package/src/index.ts

@@ -40,6 +40,7 @@ export async function start(): Promise<void> {
     authorizedChatId: resolved.chatId,
     workspace,
     model: resolved.model,
+    timezone: resolved.timezone,
     stt: resolved.openaiApiKey ? new SpeechToText(resolved.openaiApiKey) : undefined,
   };
 

package/src/orchestrator.test.ts

@@ -116,6 +116,8 @@ function makeOrchestrator(claude: Claude, extraConfig?: Partial<OrchestratorConf
   const onResponse = mock(async (r: OrchestratorResponse) => { responses.push(r); });
   const orch = new Orchestrator({
     workspace: TEST_WORKSPACE,
+    model: "sonnet",
+    timezone: "UTC",
     settingsDir: tmpSettingsDir,
     onResponse,
     claude,
@@ -737,7 +739,7 @@ describe("Orchestrator", () => {
       const detailResponse = responses[responses.length - 1];
       expect(detailResponse.message).toContain("research-pricing");
       expect(detailResponse.message).toContain("research pricing");
-      expect(detailResponse.message).toContain("default");
+      expect(detailResponse.message).toContain("sonnet");
       expect(detailResponse.message).toContain("Status: running");
       expect(detailResponse.buttons).toHaveLength(3);
       expect(detailResponse.buttons![0]).toEqual({ text: "Peek", data: `peek:${sessionId}` });
@@ -1153,6 +1155,8 @@ describe("Orchestrator", () => {
       const failingOnResponse = mock(async (_r: OrchestratorResponse) => { throw new Error("send failed"); });
       const orch = new Orchestrator({
         workspace: TEST_WORKSPACE,
+        model: "sonnet",
+        timezone: "UTC",
         settingsDir: tmpSettingsDir,
         onResponse: failingOnResponse,
         claude,

package/src/orchestrator.ts

@@ -10,17 +10,7 @@ import {
 import { writeHistoryPrompt, writeHistoryResult } from "./history";
 import { createLogger } from "./logger";
 import { generateName } from "./naming";
-import {
-  backgroundAgentProgressEvent,
-  backgroundAgentResultEvent,
-  backgroundAgentStartEvent,
-  buttonClickEvent,
-  healthCheckEvent,
-  peekEvent,
-  SYSTEM_PROMPT,
-  scheduleTriggerEvent,
-  userMessageEvent,
-} from "./prompts";
+import { PromptBuilder } from "./prompt-builder";
 import { Queue } from "./queue";
 import { loadSessions, saveSessions } from "./sessions";
 
@@ -100,8 +90,9 @@ interface SessionInfo {
 }
 
 export interface OrchestratorConfig {
-  model?: string;
+  model: string;
   workspace: string;
+  timezone: string;
   settingsDir?: string;
   onResponse: (response: OrchestratorResponse) => Promise<void>;
   claude?: Claude;
@@ -116,6 +107,7 @@ export interface OrchestratorConfig {
 export class Orchestrator {
   #config: Omit<OrchestratorConfig , 'claude'>;
   #claude: Claude;
+  #prompts: PromptBuilder;
   #waitThreshold: number;
   #healthCheckInterval: number;
   #healthCheckTimeout: number;
@@ -127,7 +119,9 @@ export class Orchestrator {
 
   constructor(config: OrchestratorConfig) {
     this.#config = config;
-    this.#claude = config.claude ?? new Claude({ workspace: config.workspace, systemPrompt: SYSTEM_PROMPT });
+    this.#prompts = new PromptBuilder(config.timezone);
+    const envVars: Record<string, string> = { TZ: config.timezone };
+    this.#claude = config.claude ?? new Claude({ workspace: config.workspace, systemPrompt: this.#prompts.systemPrompt, envVars });
     this.#waitThreshold = config.waitThreshold ?? WAIT_THRESHOLD;
     this.#healthCheckInterval = config.healthCheckInterval ?? HEALTH_CHECK_INTERVAL_MS;
     this.#healthCheckTimeout = config.healthCheckTimeout ?? HEALTH_CHECK_TIMEOUT_MS;
@@ -149,7 +143,7 @@ export class Orchestrator {
 
   handleCron(name: string, prompt: string, model?: string, missed?: { missedBy: string; scheduledAt: string }): void {
     const cronName = `cron-${name}`;
-    const formatted = scheduleTriggerEvent(
+    const formatted = this.#prompts.scheduleTrigger(
       cronName,
       { name, missedBy: missed?.missedBy, scheduledAt: missed?.scheduledAt },
       prompt,
@@ -220,7 +214,7 @@ export class Orchestrator {
     this.#callOnResponse({ message: `Peeking at <b>${escapeHtml(session.name)}</b>...` });
 
     try {
-      const prompt = peekEvent(
+      const prompt = this.#prompts.peek(
         `peek-${session.name}`,
         session.name,
         `Only consider progress since the "${session.name}" event. Brief status update: done, in progress, remaining. 2-3 sentences max, plain text.`,
@@ -438,9 +432,9 @@ export class Orchestrator {
   #formatPrompt(request: OrchestratorRequest, name: string, backgroundedEvent?: string): string {
     switch (request.type) {
       case "user":
-        return userMessageEvent(name, request.message || "", { files: request.files, backgroundedEvent });
+        return this.#prompts.userMessage(name, request.message || "", { files: request.files, backgroundedEvent });
       case "background-agent-result":
-        return backgroundAgentResultEvent(
+        return this.#prompts.backgroundAgentResult(
           name,
           request.name,
           { text: request.response.message || "[No output]", files: request.response.files },
@@ -448,7 +442,7 @@ export class Orchestrator {
           { backgroundedEvent },
         );
       case "background-agent-progress":
-        return backgroundAgentProgressEvent(
+        return this.#prompts.backgroundAgentProgress(
           name,
           request.name,
           request.progress,
@@ -456,7 +450,7 @@ export class Orchestrator {
           { backgroundedEvent },
         );
       case "button":
-        return buttonClickEvent(name, request.label, { backgroundedEvent });
+        return this.#prompts.buttonClick(name, request.label, { backgroundedEvent });
     }
   }
 
@@ -491,7 +485,7 @@ export class Orchestrator {
   // --- Background management ---
 
   #spawnBackground(name: string, prompt: string, model: string | undefined) {
-    const formatted = backgroundAgentStartEvent(name, prompt);
+    const formatted = this.#prompts.backgroundAgentStart(name, prompt);
     this.#spawnBackgroundRaw(name, prompt, formatted, model);
   }
 
@@ -555,7 +549,7 @@ export class Orchestrator {
 
     log.debug({ name: info.name, sessionId }, "Running health check");
 
-    const prompt = healthCheckEvent(
+    const prompt = this.#prompts.healthCheck(
       `health-check-${info.name}`,
       info.name,
       "Report your current status. If your task is complete, set finished=true and provide the full output. If still working, set finished=false and describe current progress in one sentence.",

package/src/{prompts.test.ts → prompt-builder.test.ts}

@@ -1,75 +1,74 @@
 import { describe, expect, it } from "bun:test";
-import {
-  backgroundAgentProgressEvent,
-  backgroundAgentResultEvent,
-  backgroundAgentStartEvent,
-  buttonClickEvent,
-  healthCheckEvent,
-  peekEvent,
-  SYSTEM_PROMPT,
-  scheduleTriggerEvent,
-  userMessageEvent,
-} from "./prompts";
-
-describe("SYSTEM_PROMPT", () => {
+import { PromptBuilder } from "./prompt-builder";
+
+const p = new PromptBuilder("UTC");
+
+describe("systemPrompt", () => {
   it("contains key sections", () => {
-    expect(SYSTEM_PROMPT).toContain("macroclaw");
-    expect(SYSTEM_PROMPT).toContain("Structured output");
-    expect(SYSTEM_PROMPT).toContain("Event format");
-    expect(SYSTEM_PROMPT).toContain("Background agents");
-    expect(SYSTEM_PROMPT).toContain("Cron");
-    expect(SYSTEM_PROMPT).toContain("Buttons");
-    expect(SYSTEM_PROMPT).toContain("Files");
-    expect(SYSTEM_PROMPT).toContain("Session routing");
+    expect(p.systemPrompt).toContain("macroclaw");
+    expect(p.systemPrompt).toContain("Structured output");
+    expect(p.systemPrompt).toContain("Event format");
+    expect(p.systemPrompt).toContain("Background agents");
+    expect(p.systemPrompt).toContain("Cron");
+    expect(p.systemPrompt).toContain("Buttons");
+    expect(p.systemPrompt).toContain("Files");
+    expect(p.systemPrompt).toContain("Session routing");
   });
 
   it("contains HTML formatting instructions", () => {
-    expect(SYSTEM_PROMPT).toContain("HTML parse mode");
-    expect(SYSTEM_PROMPT).toContain("<b>");
+    expect(p.systemPrompt).toContain("HTML parse mode");
+    expect(p.systemPrompt).toContain("<b>");
   });
 
   it("documents all event types", () => {
-    expect(SYSTEM_PROMPT).toContain("user-message");
-    expect(SYSTEM_PROMPT).toContain("button-click");
-    expect(SYSTEM_PROMPT).toContain("schedule-trigger");
-    expect(SYSTEM_PROMPT).toContain("background-agent-start");
-    expect(SYSTEM_PROMPT).toContain("background-agent-result");
-    expect(SYSTEM_PROMPT).toContain("peek");
+    expect(p.systemPrompt).toContain("user-message");
+    expect(p.systemPrompt).toContain("button-click");
+    expect(p.systemPrompt).toContain("schedule-trigger");
+    expect(p.systemPrompt).toContain("background-agent-start");
+    expect(p.systemPrompt).toContain("background-agent-result");
+    expect(p.systemPrompt).toContain("peek");
   });
 
   it("documents backgrounded events", () => {
-    expect(SYSTEM_PROMPT).toContain("backgrounded-event");
-    expect(SYSTEM_PROMPT).toContain("moved to background");
-    expect(SYSTEM_PROMPT).toContain("Do not re-execute");
+    expect(p.systemPrompt).toContain("backgrounded-event");
+    expect(p.systemPrompt).toContain("moved to background");
+    expect(p.systemPrompt).toContain("Do not re-execute");
   });
 
   it("contains structured output reinforcement", () => {
-    expect(SYSTEM_PROMPT).toContain("StructuredOutput tool");
-    expect(SYSTEM_PROMPT).toContain("actionReason");
+    expect(p.systemPrompt).toContain("StructuredOutput tool");
+    expect(p.systemPrompt).toContain("actionReason");
   });
 
   it("contains no personal names", () => {
-    expect(SYSTEM_PROMPT).not.toContain("Alfread");
-    expect(SYSTEM_PROMPT).not.toContain("Michal");
+    expect(p.systemPrompt).not.toContain("Alfread");
+    expect(p.systemPrompt).not.toContain("Michal");
   });
 
   it("documents background agent model options", () => {
-    expect(SYSTEM_PROMPT).toContain("haiku");
-    expect(SYSTEM_PROMPT).toContain("sonnet");
-    expect(SYSTEM_PROMPT).toContain("opus");
+    expect(p.systemPrompt).toContain("haiku");
+    expect(p.systemPrompt).toContain("sonnet");
+    expect(p.systemPrompt).toContain("opus");
+  });
+
+  it("includes timezone but not a fixed date", () => {
+    const prague = new PromptBuilder("Europe/Prague");
+    expect(prague.systemPrompt).not.toContain("Current date:");
+    expect(prague.systemPrompt).toContain("Timezone: Europe/Prague");
+    expect(prague.systemPrompt).toContain("TZ env var is set");
   });
 });
 
-describe("userMessageEvent", () => {
-  it("builds user message event", () => {
-    const result = userMessageEvent("check-logs", "hello");
-    expect(result).toStartWith('<event name="check-logs" type="user-message" session="main">');
+describe("userMessage", () => {
+  it("builds user message event with time attribute", () => {
+    const result = p.userMessage("check-logs", "hello");
+    expect(result).toMatch(/^<event time="\d{4}-\d{2}-\d{2}T\d{2}:\d{2}" name="check-logs" type="user-message" session="main">/);
     expect(result).toContain("<text>hello</text>");
     expect(result).toEndWith("</event>");
   });
 
   it("builds user message with files", () => {
-    const result = userMessageEvent("analyze-photo", "what's in this image?", {
+    const result = p.userMessage("analyze-photo", "what's in this image?", {
       files: ["/tmp/photo.jpg", "/tmp/doc.pdf"],
     });
     expect(result).toContain("<text>what's in this image?</text>");
@@ -80,7 +79,7 @@ describe("userMessageEvent", () => {
   });
 
   it("builds user message with backgrounded event", () => {
-    const result = userMessageEvent("check-logs", "check the logs", {
+    const result = p.userMessage("check-logs", "check the logs", {
       backgroundedEvent: "deploy-cluster",
     });
     expect(result).toContain('<backgrounded-event name="deploy-cluster" />');
@@ -88,7 +87,7 @@ describe("userMessageEvent", () => {
   });
 
   it("places backgrounded-event before text", () => {
-    const result = userMessageEvent("check-logs", "hello", {
+    const result = p.userMessage("check-logs", "hello", {
       backgroundedEvent: "deploy",
     });
     const bgIdx = result.indexOf("backgrounded-event");
@@ -97,33 +96,33 @@ describe("userMessageEvent", () => {
   });
 
   it("escapes XML in text content", () => {
-    const result = userMessageEvent("test", "a < b & c > d");
+    const result = p.userMessage("test", "a < b & c > d");
     expect(result).toContain("<text>a &lt; b &amp; c &gt; d</text>");
   });
 
   it("escapes XML in name attribute", () => {
-    const result = userMessageEvent('a & "b"', "test");
+    const result = p.userMessage('a & "b"', "test");
     expect(result).toContain('name="a &amp; &quot;b&quot;"');
   });
 
   it("escapes XML in backgrounded event name", () => {
-    const result = userMessageEvent("test", "hello", {
+    const result = p.userMessage("test", "hello", {
       backgroundedEvent: 'task & "stuff"',
     });
     expect(result).toContain('backgrounded-event name="task &amp; &quot;stuff&quot;"');
   });
 });
 
-describe("buttonClickEvent", () => {
+describe("buttonClick", () => {
   it("builds button click event", () => {
-    const result = buttonClickEvent("btn-yes", "Yes");
+    const result = p.buttonClick("btn-yes", "Yes");
     expect(result).toContain('type="button-click"');
     expect(result).toContain("<button>Yes</button>");
     expect(result).not.toContain("<text>");
   });
 
   it("builds button click with backgrounded event", () => {
-    const result = buttonClickEvent("btn-yes", "Yes", {
+    const result = p.buttonClick("btn-yes", "Yes", {
       backgroundedEvent: "deploy-cluster",
     });
     expect(result).toContain('<backgrounded-event name="deploy-cluster" />');
@@ -131,14 +130,14 @@ describe("buttonClickEvent", () => {
   });
 
   it("escapes XML in button label", () => {
-    const result = buttonClickEvent("btn", 'a & "b"');
+    const result = p.buttonClick("btn", 'a & "b"');
     expect(result).toContain("<button>a &amp; &quot;b&quot;</button>");
   });
 });
 
-describe("scheduleTriggerEvent", () => {
+describe("scheduleTrigger", () => {
   it("builds schedule trigger event", () => {
-    const result = scheduleTriggerEvent("cron-daily", { name: "daily" }, "check updates");
+    const result = p.scheduleTrigger("cron-daily", { name: "daily" }, "check updates");
     expect(result).toContain('type="schedule-trigger"');
     expect(result).toContain('session="background"');
     expect(result).toContain('<schedule name="daily" />');
@@ -146,7 +145,7 @@ describe("scheduleTriggerEvent", () => {
   });
 
   it("builds missed schedule trigger with attributes", () => {
-    const result = scheduleTriggerEvent(
+    const result = p.scheduleTrigger(
       "cron-reminder",
       { name: "reminder", missedBy: "15m", scheduledAt: "2026-03-20T06:00:00Z" },
       "buy milk",
@@ -157,18 +156,18 @@ describe("scheduleTriggerEvent", () => {
   });
 });
 
-describe("backgroundAgentStartEvent", () => {
+describe("backgroundAgentStart", () => {
   it("builds background agent start event", () => {
-    const result = backgroundAgentStartEvent("research", "find papers about transformers");
+    const result = p.backgroundAgentStart("research", "find papers about transformers");
     expect(result).toContain('type="background-agent-start"');
     expect(result).toContain('session="background"');
     expect(result).toContain("<text>find papers about transformers</text>");
   });
 });
 
-describe("backgroundAgentResultEvent", () => {
+describe("backgroundAgentResult", () => {
   it("builds background agent result (text only)", () => {
-    const result = backgroundAgentResultEvent(
+    const result = p.backgroundAgentResult(
       "bg-research",
       "research",
       { text: "found 3 papers" },
@@ -183,7 +182,7 @@ describe("backgroundAgentResultEvent", () => {
   });
 
   it("builds background agent result with files", () => {
-    const result = backgroundAgentResultEvent(
+    const result = p.backgroundAgentResult(
       "bg-research",
       "research",
       { text: "here are the screenshots", files: ["/tmp/screenshot.png"] },
@@ -196,7 +195,7 @@ describe("backgroundAgentResultEvent", () => {
   });
 
   it("includes instructions after result", () => {
-    const result = backgroundAgentResultEvent(
+    const result = p.backgroundAgentResult(
       "bg-research",
       "research",
       { text: "done" },
@@ -210,9 +209,9 @@ describe("backgroundAgentResultEvent", () => {
   });
 });
 
-describe("backgroundAgentProgressEvent", () => {
+describe("backgroundAgentProgress", () => {
   it("builds progress event with progress tag", () => {
-    const result = backgroundAgentProgressEvent(
+    const result = p.backgroundAgentProgress(
       "progress-research",
       "research",
       "indexing 500 documents",
@@ -225,9 +224,9 @@ describe("backgroundAgentProgressEvent", () => {
   });
 });
 
-describe("peekEvent", () => {
+describe("peek", () => {
   it("builds peek event with instructions", () => {
-    const result = peekEvent("peek-deploy", "deploy", "Brief status update.");
+    const result = p.peek("peek-deploy", "deploy", "Brief status update.");
     expect(result).toContain('type="peek"');
     expect(result).toContain('<target-event name="deploy" />');
     expect(result).toContain("<instructions>Brief status update.</instructions>");
@@ -235,9 +234,9 @@ describe("peekEvent", () => {
   });
 });
 
-describe("healthCheckEvent", () => {
+describe("healthCheck", () => {
   it("builds health check event with instructions", () => {
-    const result = healthCheckEvent("health-check-deploy", "deploy", "Report status.");
+    const result = p.healthCheck("health-check-deploy", "deploy", "Report status.");
     expect(result).toContain('type="health-check"');
     expect(result).toContain('<target-event name="deploy" />');
     expect(result).toContain("<instructions>Report status.</instructions>");