claude-tempo 0.8.0 → 0.9.0

package/CLAUDE.md

@@ -21,16 +21,19 @@ src/
 ├── workflows/
 │   ├── session.ts     # claude-session workflow
 │   └── signals.ts     # Signal/query type definitions
+├── activities/
+│   ├── outbox.ts      # Outbox delivery activities (cue, report, stop, recruit)
+│   └── schedule-fire.ts # Schedule fire activity
 ├── tools/
 │   ├── ensemble.ts    # Discover active sessions
-│   ├── cue.ts         # Send message to peer
+│   ├── cue.ts         # Send message to peer (via outbox)
 │   ├── set-name.ts    # Set session name
 │   ├── set-part.ts    # Update own summary
 │   ├── resolve.ts     # Search-attribute session lookup
 │   ├── listen.ts      # Manual message check
-│   ├── recruit.ts     # Spawn new session
-│   ├── report.ts      # Report to conductor
-│   ├── stop.ts        # Stop a session
+│   ├── recruit.ts     # Spawn new session (via outbox)
+│   ├── report.ts      # Report to conductor (via outbox)
+│   ├── stop.ts        # Stop a session (via outbox)
 │   └── helpers.ts     # Zod/MCP tool registration wrapper
 ├── types.ts           # Shared type definitions
 ├── channel.ts         # Claude channel notification helper
@@ -60,6 +63,10 @@ npm test
 > **Important**: Always run `npm run build` after changing workflow code (`src/workflows/`).
 > The build pre-bundles workflows into `workflow-bundle.js` so all workers use identical code.
 
+> **Dual workers**: Each session runs two Temporal workers — a shared `claude-tempo` queue
+> (workflows + delivery activities) and a per-host `claude-tempo-{hostname}` queue (spawn activities only).
+> Both are created via `createWorkers()` in `src/worker.ts`.
+
 ## Key Concepts
 
 - **Player**: A Claude Code session registered as a Temporal workflow
@@ -70,6 +77,8 @@ npm test
 - **Recruit**: Spawning a new Claude Code session as a player. The workflow is pre-created with the initial message before the process spawns, ensuring reliable delivery.
 - **set_name**: Players start with a random hex ID; `set_name` updates the `ClaudeTempoPlayerId` search attribute to a human-readable name
 - **Session status**: Each session has a status (`pending` → `active` → `stale`) tracked via `ClaudeTempoStatus` search attribute. Pre-created workflows start as `pending`, transition to `active` when the process connects, and become `stale` if messages go undelivered for 3+ minutes.
+- **Outbox**: Outbound requests (cue, report, stop, recruit) go through the session's own workflow outbox instead of directly signaling other workflows. The workflow's dispatch loop processes entries via activities, decoupling tools from cross-workflow signaling.
+- **Per-host task queues**: Each host runs a `claude-tempo-{hostname}` activity worker for local-only operations (e.g., `spawnProcess`). This enables cross-machine recruiting — the `recruit` tool accepts an optional `host` parameter to route the spawn to a remote machine's task queue.
 
 ## Dashboard
 

package/assets/icon-dark.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <!-- Ultra-minimal metronome icon: triangle + pendulum (dark mode) -->
+  <!-- Metronome body — single-stroke triangle -->
+  <path d="M32 8 L14 54 L50 54 Z" stroke="#FAF3EE" stroke-width="3" fill="none" stroke-linejoin="round"/>
+  <!-- Pendulum arm (angled right) -->
+  <line x1="32" y1="46" x2="44" y2="14" stroke="#E07A5F" stroke-width="3" stroke-linecap="round"/>
+  <!-- Pivot dot -->
+  <circle cx="32" cy="46" r="3" fill="#E07A5F"/>
+</svg>

package/assets/icon.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <!-- Ultra-minimal metronome icon: triangle + pendulum -->
+  <!-- Metronome body — single-stroke triangle -->
+  <path d="M32 8 L14 54 L50 54 Z" stroke="#1B2838" stroke-width="3" fill="none" stroke-linejoin="round"/>
+  <!-- Pendulum arm (angled right) -->
+  <line x1="32" y1="46" x2="44" y2="14" stroke="#E07A5F" stroke-width="3" stroke-linecap="round"/>
+  <!-- Pivot dot -->
+  <circle cx="32" cy="46" r="3" fill="#E07A5F"/>
+</svg>

package/assets/logo-dark.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 140" fill="none">
+  <!-- Ultra-minimal metronome: triangle outline + pendulum line (dark mode) -->
+  <!-- Metronome body — single-stroke triangle -->
+  <path d="M160 18 L122 100 L198 100 Z" stroke="#FAF3EE" stroke-width="3" fill="none" stroke-linejoin="round"/>
+  <!-- Pendulum arm (angled right ~18deg) -->
+  <line x1="160" y1="88" x2="182" y2="24" stroke="#E07A5F" stroke-width="3" stroke-linecap="round"/>
+  <!-- Pivot dot -->
+  <circle cx="160" cy="88" r="3.5" fill="#E07A5F"/>
+  <!-- Text -->
+  <text x="160" y="132" text-anchor="middle" font-family="'JetBrains Mono','SF Mono','Consolas',monospace" font-size="18" font-weight="600" fill="#FAF3EE" letter-spacing="-0.5">claude-tempo</text>
+</svg>

package/assets/logo-light.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 140" fill="none">
+  <!-- Ultra-minimal metronome: triangle outline + pendulum line -->
+  <!-- Metronome body — single-stroke triangle -->
+  <path d="M160 18 L122 100 L198 100 Z" stroke="#1B2838" stroke-width="3" fill="none" stroke-linejoin="round"/>
+  <!-- Pendulum arm (angled right ~18deg) -->
+  <line x1="160" y1="88" x2="182" y2="24" stroke="#E07A5F" stroke-width="3" stroke-linecap="round"/>
+  <!-- Pivot dot -->
+  <circle cx="160" cy="88" r="3.5" fill="#E07A5F"/>
+  <!-- Text -->
+  <text x="160" y="132" text-anchor="middle" font-family="'JetBrains Mono','SF Mono','Consolas',monospace" font-size="18" font-weight="600" fill="#1B2838" letter-spacing="-0.5">claude-tempo</text>
+</svg>

package/dist/activities/outbox.d.ts

@@ -0,0 +1,60 @@
+import { Client } from '@temporalio/client';
+import { Config } from '../config';
+import { AgentType } from '../types';
+export interface DeliverCueInput {
+    ensemble: string;
+    fromPlayerId: string;
+    targetPlayerId: string;
+    message: string;
+}
+export interface DeliverReportInput {
+    ensemble: string;
+    fromPlayerId: string;
+    text: string;
+    reportType: 'result' | 'blocker' | 'question';
+}
+export interface TerminateSessionInput {
+    ensemble: string;
+    targetPlayerId: string;
+    terminatedBy: string;
+}
+export interface StartRecruitedSessionInput {
+    ensemble: string;
+    targetName: string;
+    workDir: string;
+    isConductor: boolean;
+    initialMessage?: string;
+    fromPlayerId: string;
+    agent: AgentType;
+    systemPrompt?: string;
+    taskQueue: string;
+}
+export interface SpawnProcessInput {
+    targetName: string;
+    workDir: string;
+    isConductor: boolean;
+    agent: AgentType;
+    systemPrompt?: string;
+    ensemble: string;
+    temporalAddress: string;
+    temporalNamespace: string;
+    temporalApiKey?: string;
+    temporalTlsCertPath?: string;
+    temporalTlsKeyPath?: string;
+}
+export interface OutboxActivityResult {
+    success: boolean;
+    error?: string;
+}
+export interface OutboxActivities {
+    deliverCue(input: DeliverCueInput): Promise<OutboxActivityResult>;
+    deliverReport(input: DeliverReportInput): Promise<OutboxActivityResult>;
+    terminateSession(input: TerminateSessionInput): Promise<OutboxActivityResult>;
+    startRecruitedSession(input: StartRecruitedSessionInput): Promise<OutboxActivityResult>;
+    spawnProcess(input: SpawnProcessInput): Promise<OutboxActivityResult>;
+}
+/**
+ * Create outbox delivery activities bound to a Temporal client and config.
+ * The returned object is registered with the worker as activities.
+ */
+export declare function createOutboxActivities(client: Client, config: Config): OutboxActivities;

package/dist/activities/outbox.js

@@ -0,0 +1,203 @@
+"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.createOutboxActivities = createOutboxActivities;
+const client_1 = require("@temporalio/client");
+const activity_1 = require("@temporalio/activity");
+const os = __importStar(require("os"));
+const config_1 = require("../config");
+const git_info_1 = require("../git-info");
+const spawn_1 = require("../spawn");
+const config_2 = require("../config");
+const log = (...args) => console.error('[claude-tempo:outbox]', ...args);
+// ── Helper: resolve session by player name ──
+async function resolveSession(client, ensemble, playerName) {
+    const query = `WorkflowType = "claudeSessionWorkflow" AND ExecutionStatus = "Running"`;
+    for await (const wf of client.workflow.list({ query })) {
+        try {
+            const handle = client.workflow.getHandle(wf.workflowId);
+            const metadata = await handle.query('getMetadata');
+            if (metadata.ensemble === ensemble && metadata.playerId === playerName) {
+                return handle;
+            }
+        }
+        catch {
+            // Workflow may have just completed — skip
+        }
+    }
+    return null;
+}
+/**
+ * Create outbox delivery activities bound to a Temporal client and config.
+ * The returned object is registered with the worker as activities.
+ */
+function createOutboxActivities(client, config) {
+    return {
+        async deliverCue(input) {
+            const { ensemble, fromPlayerId, targetPlayerId, message } = input;
+            const handle = await resolveSession(client, ensemble, targetPlayerId);
+            if (!handle) {
+                throw activity_1.ApplicationFailure.nonRetryable(`No active session found for "${targetPlayerId}"`);
+            }
+            await handle.signal('receiveMessage', { from: fromPlayerId, text: message });
+            return { success: true };
+        },
+        async deliverReport(input) {
+            const { ensemble, fromPlayerId, text, reportType } = input;
+            const conductorId = (0, config_1.conductorWorkflowId)(ensemble);
+            const handle = client.workflow.getHandle(conductorId);
+            await handle.signal('playerReport', { playerId: fromPlayerId, text, type: reportType });
+            return { success: true };
+        },
+        async terminateSession(input) {
+            const { ensemble, targetPlayerId, terminatedBy } = input;
+            const handle = await resolveSession(client, ensemble, targetPlayerId);
+            if (!handle) {
+                throw activity_1.ApplicationFailure.nonRetryable(`No active session found for "${targetPlayerId}"`);
+            }
+            // Signal target to mark as terminated
+            await handle.signal('updateMetadata', { status: 'terminated', terminatedBy });
+            // Notify conductor about the termination (best effort)
+            try {
+                const conductorId = (0, config_1.conductorWorkflowId)(ensemble);
+                const conductorHandle = client.workflow.getHandle(conductorId);
+                await conductorHandle.signal('receiveMessage', {
+                    from: 'system',
+                    text: `Session "${targetPlayerId}" was terminated by ${terminatedBy}.`,
+                });
+            }
+            catch {
+                // Conductor may not exist — that's fine
+            }
+            return { success: true };
+        },
+        async startRecruitedSession(input) {
+            const { ensemble, targetName, workDir, isConductor, initialMessage, fromPlayerId, agent, systemPrompt, taskQueue } = input;
+            try {
+                const workflowId = isConductor
+                    ? (0, config_1.conductorWorkflowId)(ensemble)
+                    : (0, config_1.sessionWorkflowId)(ensemble, targetName);
+                const { gitRoot, gitBranch } = (0, git_info_1.getGitInfo)(workDir);
+                const sessionInput = {
+                    metadata: {
+                        playerId: targetName,
+                        ensemble,
+                        hostname: os.hostname(),
+                        workDir,
+                        gitRoot,
+                        gitBranch,
+                        isConductor,
+                        agentType: agent,
+                        status: 'pending',
+                    },
+                    autoSummary: `Session in ${require('path').basename(workDir)}`,
+                    disableStaleDetection: true,
+                    ...(initialMessage ? {
+                        messages: [{
+                                id: require('crypto').randomUUID(),
+                                from: fromPlayerId,
+                                text: initialMessage,
+                                timestamp: new Date().toISOString(),
+                                delivered: false,
+                            }],
+                    } : {}),
+                };
+                await client.workflow.start('claudeSessionWorkflow', {
+                    workflowId,
+                    taskQueue,
+                    args: [sessionInput],
+                    workflowIdConflictPolicy: client_1.WorkflowIdConflictPolicy.USE_EXISTING,
+                    searchAttributes: {
+                        ...(gitRoot ? { ClaudeTempoGitRoot: [gitRoot] } : {}),
+                        ClaudeTempoHostname: [os.hostname()],
+                        ClaudeTempoEnsemble: [ensemble],
+                        ClaudeTempoPlayerId: [targetName],
+                    },
+                });
+                log(`Pre-created workflow ${workflowId} for recruit "${targetName}"`);
+                return { success: true };
+            }
+            catch (err) {
+                throw activity_1.ApplicationFailure.nonRetryable(`Failed to start recruited session "${targetName}": ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        async spawnProcess(input) {
+            const { targetName, workDir, isConductor, agent, systemPrompt, ensemble, temporalAddress, temporalNamespace, temporalApiKey, temporalTlsCertPath, temporalTlsKeyPath } = input;
+            try {
+                if (agent === 'copilot') {
+                    const { pid } = (0, spawn_1.spawnCopilotBridge)({
+                        name: targetName,
+                        ensemble,
+                        temporalAddress,
+                        temporalNamespace,
+                        temporalApiKey,
+                        temporalTlsCertPath,
+                        temporalTlsKeyPath,
+                        isConductor,
+                        workDir,
+                    });
+                    log(`Spawned copilot-bridge (pid ${pid}) in ${workDir} as "${targetName}"`);
+                }
+                else {
+                    const spawnArgs = [
+                        '--dangerously-skip-permissions',
+                        '--dangerously-load-development-channels', 'server:claude-tempo',
+                        '-n', targetName,
+                        ...(systemPrompt ? ['--system-prompt', systemPrompt] : []),
+                    ];
+                    const envVars = {
+                        [config_2.ENV.ENSEMBLE]: ensemble,
+                        [config_2.ENV.CONDUCTOR]: isConductor ? 'true' : '',
+                        [config_2.ENV.PLAYER_NAME]: targetName,
+                        [config_2.ENV.TEMPORAL_ADDRESS]: temporalAddress,
+                        [config_2.ENV.TEMPORAL_NAMESPACE]: temporalNamespace,
+                    };
+                    if (temporalApiKey)
+                        envVars[config_2.ENV.TEMPORAL_API_KEY] = temporalApiKey;
+                    if (temporalTlsCertPath)
+                        envVars[config_2.ENV.TEMPORAL_TLS_CERT_PATH] = temporalTlsCertPath;
+                    if (temporalTlsKeyPath)
+                        envVars[config_2.ENV.TEMPORAL_TLS_KEY_PATH] = temporalTlsKeyPath;
+                    const { pid } = (0, spawn_1.spawnInTerminal)(spawnArgs, workDir, envVars);
+                    log(`Spawned claude process (pid ${pid}) in ${workDir} as "${targetName}"`);
+                }
+                return { success: true };
+            }
+            catch (err) {
+                throw activity_1.ApplicationFailure.nonRetryable(`Failed to spawn process for "${targetName}": ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+    };
+}

package/dist/config.d.ts

@@ -85,6 +85,8 @@ export interface ConfigWithSources {
  * Used by `claude-tempo config show` to help users debug.
  */
 export declare function getConfigWithSources(overrides?: CliOverrides): ConfigWithSources;
+/** Build a per-host task queue name for cross-machine activities: {taskQueue}-{hostname} */
+export declare function hostTaskQueue(taskQueue: string, hostname: string): string;
 /** Build a workflow ID for a player session: claude-session-{ensemble}-{playerId} */
 export declare function sessionWorkflowId(ensemble: string, playerId: string): string;
 /** Build a workflow ID for a conductor: claude-session-{ensemble}-conductor */

package/dist/config.js

@@ -7,6 +7,7 @@ exports.loadTemporalCliConfig = loadTemporalCliConfig;
 exports.parseTemporalYaml = parseTemporalYaml;
 exports.getConfig = getConfig;
 exports.getConfigWithSources = getConfigWithSources;
+exports.hostTaskQueue = hostTaskQueue;
 exports.sessionWorkflowId = sessionWorkflowId;
 exports.conductorWorkflowId = conductorWorkflowId;
 exports.schedulerWorkflowId = schedulerWorkflowId;
@@ -239,6 +240,10 @@ function getConfigWithSources(overrides = {}) {
         },
     };
 }
+/** Build a per-host task queue name for cross-machine activities: {taskQueue}-{hostname} */
+function hostTaskQueue(taskQueue, hostname) {
+    return `${taskQueue}-${hostname}`;
+}
 /** Build a workflow ID for a player session: claude-session-{ensemble}-{playerId} */
 function sessionWorkflowId(ensemble, playerId) {
     return `claude-session-${ensemble}-${playerId}`;

package/dist/server.js

@@ -88,11 +88,16 @@ async function main() {
         connection,
         namespace: config.temporalNamespace,
     });
-    // Start the Temporal worker (runs in background)
-    const worker = await (0, worker_1.createWorker)(config);
-    const workerRunPromise = worker.run();
-    workerRunPromise.catch((err) => {
-        log('Worker error:', err);
+    // Start the Temporal workers (runs in background)
+    const { sharedWorker, hostWorker } = await (0, worker_1.createWorkers)(config);
+    const sharedWorkerRunPromise = sharedWorker.run();
+    const hostWorkerRunPromise = hostWorker.run();
+    sharedWorkerRunPromise.catch((err) => {
+        log('Shared worker error:', err);
+        process.exit(1);
+    });
+    hostWorkerRunPromise.catch((err) => {
+        log('Host worker error:', err);
         process.exit(1);
     });
     // Start the session workflow
@@ -112,6 +117,14 @@ async function main() {
             agentType: isBridgeMode ? 'copilot' : 'claude',
         },
         autoSummary: `Session in ${path.basename(workDir)}`,
+        temporalConfig: {
+            temporalAddress: config.temporalAddress,
+            temporalNamespace: config.temporalNamespace,
+            temporalApiKey: config.temporalApiKey,
+            temporalTlsCertPath: config.temporalTlsCertPath,
+            temporalTlsKeyPath: config.temporalTlsKeyPath,
+            taskQueue: config.taskQueue,
+        },
     };
     const handle = await client.workflow.start('claudeSessionWorkflow', {
         workflowId,
@@ -129,19 +142,25 @@ async function main() {
     log(`Workflow ${workflowId} started (or reconnected)`);
     // Watch for workflow completion — exit the process when the workflow ends
     // (e.g., via stop tool setting status to 'terminated')
+    const shutdownWorkers = () => {
+        sharedWorker.shutdown();
+        hostWorker.shutdown();
+        return Promise.all([
+            sharedWorkerRunPromise.catch(() => { }),
+            hostWorkerRunPromise.catch(() => { }),
+        ]);
+    };
     handle.result().then(() => {
         log('Workflow completed — shutting down');
         stopPoller();
-        worker.shutdown();
-        workerRunPromise.catch(() => { }).then(() => process.exit(0));
+        shutdownWorkers().then(() => process.exit(0));
     }).catch((err) => {
         // Only exit on workflow-level errors (cancelled, failed), not transient connection errors
         const name = err?.name || '';
         if (name.includes('WorkflowFailed') || name.includes('WorkflowCancelled') || name.includes('WorkflowNotFound')) {
             log('Workflow ended unexpectedly — shutting down');
             stopPoller();
-            worker.shutdown();
-            workerRunPromise.catch(() => { }).then(() => process.exit(1));
+            shutdownWorkers().then(() => process.exit(1));
         }
         else {
             log('Transient error watching workflow result:', err?.message || err);
@@ -192,13 +211,13 @@ async function main() {
     });
     // Register tools
     (0, ensemble_1.registerEnsembleTool)(mcpServer, client, config, getPlayerId, workflowId);
-    (0, cue_1.registerCueTool)(mcpServer, client, config, getPlayerId);
+    (0, cue_1.registerCueTool)(mcpServer, client, config, getPlayerId, handle);
     (0, set_part_1.registerSetPartTool)(mcpServer, handle);
     (0, set_name_1.registerSetNameTool)(mcpServer, client, config, handle, getPlayerId, setPlayerId);
     (0, listen_1.registerListenTool)(mcpServer, handle);
-    (0, recruit_1.registerRecruitTool)(mcpServer, client, config, getPlayerId, isBridgeMode ? 'copilot' : 'claude');
-    (0, report_1.registerReportTool)(mcpServer, client, config, getPlayerId);
-    (0, stop_1.registerStopTool)(mcpServer, client, config, getPlayerId);
+    (0, recruit_1.registerRecruitTool)(mcpServer, client, config, getPlayerId, handle, isBridgeMode ? 'copilot' : 'claude');
+    (0, report_1.registerReportTool)(mcpServer, handle);
+    (0, stop_1.registerStopTool)(mcpServer, client, config, getPlayerId, handle);
     (0, schedule_1.registerScheduleTool)(mcpServer, client, config, getPlayerId);
     (0, unschedule_1.registerUnscheduleTool)(mcpServer, client, config);
     (0, schedules_1.registerSchedulesTool)(mcpServer, client, config);
@@ -246,8 +265,7 @@ async function main() {
         catch {
             // workflow may already be gone
         }
-        worker.shutdown();
-        await workerRunPromise.catch(() => { });
+        await shutdownWorkers();
         process.exit(0);
     };
     process.on('SIGINT', shutdown);

package/dist/spawn.d.ts

@@ -1,3 +1,13 @@
+/** Resolve the absolute path to the package's icon file (PNG for Windows Terminal). */
+export declare function resolveIconPath(): string;
+/**
+ * Ensure a "claude-tempo" profile exists in Windows Terminal settings.json
+ * with our icon. Returns true if the profile is ready for use.
+ *
+ * Windows Terminal settings path:
+ *   %LOCALAPPDATA%/Packages/Microsoft.WindowsTerminal_8wekyb3d8bbwe/LocalState/settings.json
+ */
+export declare function ensureWindowsTerminalProfile(): boolean;
 /** POSIX shell-safe single-quoting (works in bash, zsh, and fish) */
 export declare function shellQuote(s: string): string;
 /** Resolve the absolute path to the `claude` binary */

package/dist/spawn.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveIconPath = resolveIconPath;
+exports.ensureWindowsTerminalProfile = ensureWindowsTerminalProfile;
 exports.shellQuote = shellQuote;
 exports.resolveClaudePath = resolveClaudePath;
 exports.detectMacTerminal = detectMacTerminal;
@@ -13,6 +15,117 @@ const path_1 = require("path");
 const os_1 = require("os");
 const config_1 = require("./config");
 const log = (...args) => console.error('[claude-tempo:spawn]', ...args);
+/** Stable GUID for the claude-tempo Windows Terminal profile. */
+const WT_PROFILE_GUID = '{c1a0d300-0e30-4000-a000-c1a0de00e300}';
+const WT_PROFILE_NAME = 'claude-tempo';
+/** Resolve the absolute path to the package's icon file (PNG for Windows Terminal). */
+function resolveIconPath() {
+    // __dirname is src/ in dev or dist/ in production; assets/ is at the package root
+    const packageRoot = (0, path_1.resolve)(__dirname, '..');
+    return (0, path_1.join)(packageRoot, 'assets', 'icon-dark-32.png');
+}
+/**
+ * Strip // and /* comments from JSON-with-comments (JSONC), leaving strings intact.
+ * Handles escaped quotes inside strings correctly.
+ */
+function stripJsonComments(text) {
+    let result = '';
+    let i = 0;
+    while (i < text.length) {
+        // String literal — copy verbatim until closing quote
+        if (text[i] === '"') {
+            result += '"';
+            i++;
+            while (i < text.length && text[i] !== '"') {
+                if (text[i] === '\\') {
+                    result += text[i++];
+                } // skip escaped char
+                if (i < text.length) {
+                    result += text[i++];
+                }
+            }
+            if (i < text.length) {
+                result += text[i++];
+            } // closing quote
+            // Line comment
+        }
+        else if (text[i] === '/' && text[i + 1] === '/') {
+            while (i < text.length && text[i] !== '\n')
+                i++;
+            // Block comment
+        }
+        else if (text[i] === '/' && text[i + 1] === '*') {
+            i += 2;
+            while (i < text.length && !(text[i] === '*' && text[i + 1] === '/'))
+                i++;
+            i += 2; // skip closing */
+        }
+        else {
+            result += text[i++];
+        }
+    }
+    return result;
+}
+/**
+ * Ensure a "claude-tempo" profile exists in Windows Terminal settings.json
+ * with our icon. Returns true if the profile is ready for use.
+ *
+ * Windows Terminal settings path:
+ *   %LOCALAPPDATA%/Packages/Microsoft.WindowsTerminal_8wekyb3d8bbwe/LocalState/settings.json
+ */
+function ensureWindowsTerminalProfile() {
+    if (process.platform !== 'win32')
+        return false;
+    const localAppData = process.env.LOCALAPPDATA;
+    if (!localAppData)
+        return false;
+    const settingsPath = (0, path_1.join)(localAppData, 'Packages', 'Microsoft.WindowsTerminal_8wekyb3d8bbwe', 'LocalState', 'settings.json');
+    if (!(0, fs_1.existsSync)(settingsPath)) {
+        log('Windows Terminal settings.json not found at', settingsPath);
+        return false;
+    }
+    try {
+        const raw = (0, fs_1.readFileSync)(settingsPath, 'utf8');
+        // Windows Terminal settings.json may contain comments — strip them for JSON.parse.
+        // Naive regex would eat "//" inside strings (e.g., URLs). Walk char-by-char instead.
+        const settings = JSON.parse(stripJsonComments(raw));
+        if (!settings.profiles?.list)
+            return false;
+        const iconPath = resolveIconPath().replace(/\\/g, '/');
+        if (!(0, fs_1.existsSync)(iconPath.replace(/\//g, '\\'))) {
+            log('Icon file not found at', iconPath);
+            return false;
+        }
+        const profiles = settings.profiles.list;
+        // Check if our profile already exists (by GUID or name)
+        const existing = profiles.find((p) => p.guid === WT_PROFILE_GUID || p.name === WT_PROFILE_NAME);
+        if (existing) {
+            // Update icon path if it changed (e.g. package moved)
+            if (existing.icon !== iconPath) {
+                existing.icon = iconPath;
+                (0, fs_1.writeFileSync)(settingsPath, JSON.stringify(settings, null, 4) + '\n');
+                log('Updated claude-tempo profile icon in Windows Terminal');
+            }
+            return true;
+        }
+        // Add new profile
+        profiles.push({
+            guid: WT_PROFILE_GUID,
+            name: WT_PROFILE_NAME,
+            commandline: 'cmd.exe',
+            icon: iconPath,
+            hidden: true, // Hide from dropdown — only used programmatically
+        });
+        // Write back with original formatting style (4-space indent to match WT default)
+        (0, fs_1.writeFileSync)(settingsPath, JSON.stringify(settings, null, 4) + '\n');
+        log('Created claude-tempo profile in Windows Terminal with icon:', iconPath);
+        return true;
+    }
+    catch (e) {
+        log('Failed to update Windows Terminal settings:', e);
+        return false;
+    }
+}
 /** POSIX shell-safe single-quoting (works in bash, zsh, and fish) */
 function shellQuote(s) {
     return `'${s.replace(/'/g, "'\\''")}'`;
@@ -186,6 +299,8 @@ function spawnInTerminal(claudeArgs, workDir, envVars) {
             const tabTitle = nameIdx !== -1 && nameIdx + 1 < claudeArgs.length
                 ? claudeArgs[nameIdx + 1]
                 : 'claude-tempo';
+            // Ensure our profile with icon exists in Windows Terminal settings
+            const hasProfile = ensureWindowsTerminalProfile();
             // Build inline env var assignments for cmd /c since wt.exe spawns
             // a new process that won't inherit our env.
             // Escape values for cmd.exe: wrap in quotes and escape inner special chars.
@@ -198,14 +313,17 @@ function spawnInTerminal(claudeArgs, workDir, envVars) {
                 ? `${setCmds} && ${claudeCmd}`
                 : claudeCmd;
             // Use `cmd.exe /c start "" wt.exe ...` to resolve the UWP app alias
-            const child = (0, child_process_1.spawn)('cmd.exe', [
+            // When our profile exists, use --profile to get the tab icon
+            const wtArgs = [
                 '/c', 'start', '',
                 'wt.exe', '-w', '0',
                 'new-tab',
+                ...(hasProfile ? ['--profile', WT_PROFILE_NAME] : []),
                 '--title', tabTitle,
                 '-d', workDir,
                 'cmd', '/k', innerCmd,
-            ], {
+            ];
+            const child = (0, child_process_1.spawn)('cmd.exe', wtArgs, {
                 detached: true,
                 stdio: 'ignore',
             });