@turns/dev 0.0.23 → 0.0.24

package/README.md

@@ -69,6 +69,13 @@ On macOS, credentials and daemon state live under
 LaunchAgent `~/Library/LaunchAgents/dev.turns.cli.plist`. Its output is written
 to `~/Library/Application Support/turns/daemon.log`.
 
+Daemon runtime logs (including reconnects, upload progress, and errors) prefix
+each line with a UTC ISO 8601 timestamp, for example
+`[2026-10-19T09:12:34.567Z] Reconnected to wss://turns.dev/api/socket ...`.
+Foreground uploads use the same timestamped runtime logs. Multiline messages
+share one timestamp and retain their indentation; stdout and stderr remain
+separate. Help, version, and service-management output keep their plain format.
+
 The credential file contains a seven-day access token and a signed refresh
 token. The CLI refreshes the access token at least once every 24 hours. A new
 machine opens a one-time turns.dev URL, waits on an authentication WebSocket,

package/dist/harness-registry.js

@@ -372,7 +372,7 @@ export function processInvocation({ harness, sessionId, transcriptPath, cwd, pro
                 sessionId,
                 ...(!createSession ? ['--allow-workspace-switch'] : []),
                 ...(model && model !== 'auto' ? ['--model', model] : []),
-                ...(thinkingLevel ? ['--reasoning-effort', thinkingLevel === 'max' ? 'ultra' : thinkingLevel] : []),
+                ...(thinkingLevel ? ['--reasoning-effort', thinkingLevel] : []),
                 prompt,
             ],
         };

package/dist/index.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { applicationPaths, authenticate, CREDENTIAL_REFRESH_INTERVAL_MS, credentialsNeedRefresh, exchangeLegacyToken, normalizeOrigin, readCredentials, recoverRejectedCredentials, refreshCredentials, removeCredentials, uploadSocketUrl, writeCredentials, } from "./auth.js";
 import { daemonStatus, installDaemon, uninstallDaemon } from "./daemon.js";
 import { normalizeAllowedDirectories } from "./directory-policy.js";
+import { logError, logInfo } from "./logging.js";
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const CLI_DIRECTORY = path.basename(HERE) === 'dist' ? path.dirname(HERE) : HERE;
 const pkg = JSON.parse(fs.readFileSync(path.join(CLI_DIRECTORY, 'package.json'), 'utf8'));
@@ -50,11 +51,11 @@ export async function migrateLegacyCredentials(paths, origin, { legacyTokenFile
         const credentials = await exchangeLegacyToken(normalizeOrigin(origin || 'https://turns.dev'), legacyToken);
         writeCredentials(credentials, paths);
         fs.unlinkSync(legacyTokenFile);
-        process.stdout.write(`Upgraded the existing uploader credential for @${credentials.user.login}.\n`);
+        logInfo(`Upgraded the existing uploader credential for @${credentials.user.login}.\n`);
         return credentials;
     }
     catch (error) {
-        process.stderr.write(`Could not upgrade the existing uploader credential: ${error.message}\n`);
+        logError(`Could not upgrade the existing uploader credential: ${error.message}\n`);
         return null;
     }
 }
@@ -166,7 +167,7 @@ function credentialProvider(initial, { paths, interactive }) {
     };
     const timer = setInterval(() => {
         refreshIfDue().catch((error) => {
-            process.stderr.write(`Turns credential refresh failed: ${error.message}; retrying later.\n`);
+            logError(`Turns credential refresh failed: ${error.message}; retrying later.\n`);
         });
     }, Math.min(CREDENTIAL_REFRESH_INTERVAL_MS, 60 * 60_000));
     timer.unref?.();
@@ -282,7 +283,7 @@ async function main(rawArguments = process.argv.slice(2)) {
             credentials = await authenticate({ origin: parsed.origin, paths, interactive: false });
         }
         if (allowedDirectories.length) {
-            process.stdout.write(`Daemon directory allowlist:\n${allowedDirectories.map((value) => `  ${value}`).join('\n')}\n`);
+            logInfo(`Daemon directory allowlist:\n${allowedDirectories.map((value) => `  ${value}`).join('\n')}\n`);
         }
         await runUpload(credentials, {
             paths,
@@ -312,7 +313,7 @@ async function main(rawArguments = process.argv.slice(2)) {
     const selected = scopedWatchOptions(command === 'upload' ? argv[1] || process.cwd() : process.cwd(), {
         once: parsed.once,
     });
-    process.stdout.write(selected.watch
+    logInfo(selected.watch
         ? `Watching sessions in ${selected.directory} as @${credentials.user.login}. Press Ctrl-C to stop.\n`
         : `Uploading sessions in ${selected.directory} as @${credentials.user.login}.\n`);
     await runUpload(credentials, {
@@ -330,7 +331,7 @@ try {
 catch { }
 if (invokedAsMain) {
     main().catch((error) => {
-        process.stderr.write(`turns: ${error?.message || error}\n`);
+        logError(`turns: ${error?.message || error}\n`);
         process.exitCode = 1;
     });
 }

package/dist/logging.js

@@ -0,0 +1,14 @@
+import process from 'node:process';
+/** Callers supply complete log messages, including their trailing newline. */
+export function formatLogMessage(message, now = new Date()) {
+    const prefix = `[${now.toISOString()}] `;
+    // Timestamp every physical line, but do not add a dangling prefix after the
+    // final newline. Keep indentation and use one time for the whole message.
+    return message.replace(/^(?=[\s\S])/gmu, prefix);
+}
+export function logInfo(message) {
+    return process.stdout.write(formatLogMessage(message));
+}
+export function logError(message) {
+    return process.stderr.write(formatLogMessage(message));
+}

package/dist/path-resolution.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { Transform } from 'node:stream';
+import { logError } from "./logging.js";
 /**
  * Turning the paths an agent writes into things a reader can open.
  *
@@ -526,7 +527,7 @@ export function createPathResolver({ options, machine, baseUrl, appendResolution
             }
             const chain = (chains.get(sessionId) || Promise.resolve()).then(() => resolveBatch(sessionId, workingDirectory, fresh).catch((error) => {
                 const message = error?.message || String(error);
-                process.stderr.write(`Path resolution failed: ${redactor ? redactor.redactText(message) : message}\n`);
+                logError(`Path resolution failed: ${redactor ? redactor.redactText(message) : message}\n`);
             }));
             chains.set(sessionId, chain);
             return chain;

package/dist/queue-worker.js

@@ -4,6 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
+import { logError } from "./logging.js";
 import { anchorId, connectExistingAgentAnchors, launchAgentAnchor, waitForAgentTurn } from "./agent-anchor-client.js";
 import { createCodexUpdateManager } from "./codex-update.js";
 import { isAsyncQuestionId } from "./codex-async-question-recovery.js";
@@ -384,7 +385,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 catch (error) {
                     const message = String(error?.message || error);
                     state.failures = (state.failures || 0) + 1;
-                    process.stderr.write(`Runtime event append failed for ${sessionId}: ${message}\n`);
+                    logError(`Runtime event append failed for ${sessionId}: ${message}\n`);
                     // Socket failures are retried inside request(). Keep valid anchor
                     // events across other transient Worker/R2 failures too. Only discard
                     // a batch when the session is gone or the internally constructed row
@@ -399,7 +400,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                         state.failures = 0;
                     }
                     else if (state.failures >= MAX_RUNTIME_FLUSH_FAILURES) {
-                        process.stderr.write(`Dropping ${events.length} undeliverable runtime events for ${sessionId} after ` +
+                        logError(`Dropping ${events.length} undeliverable runtime events for ${sessionId} after ` +
                             `${state.failures} attempts: ${message}\n`);
                         state.events.splice(0, events.length);
                         state.failures = 0;
@@ -504,7 +505,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                     if (state === 'idle')
                         await flushRuntime(sessionId);
                     await reportHarness(sessionId, state, entry);
-                })().catch((error) => process.stderr.write(`Harness status upload failed: ${error?.message || error}\n`));
+                })().catch((error) => logError(`Harness status upload failed: ${error?.message || error}\n`));
             }
             if (message.type === 'live_event') {
                 const turnMessageId = String(message.messageId || entry.snapshot.currentTurn?.messageId || '');
@@ -633,7 +634,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
         // Dispatch deliberately does not wait for that publish: the queue preserves
         // order on its own, and a frame the Worker will not accept must not be able
         // to hold a claimed prompt back from the agent.
-        void enqueueRuntime(sessionId, queuePromptBoundary(recovery?.entry || anchors.get(sessionId), claim), true).catch((error) => process.stderr.write(`Queue prompt boundary publish failed for ${sessionId}: ${error?.message || error}\n`));
+        void enqueueRuntime(sessionId, queuePromptBoundary(recovery?.entry || anchors.get(sessionId), claim), true).catch((error) => logError(`Queue prompt boundary publish failed for ${sessionId}: ${error?.message || error}\n`));
         let descriptor;
         let agentSessionId = '';
         let creating = false;
@@ -717,7 +718,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                     void reportHarness(sessionId, 'stopped', entry).catch(() => { });
                     return;
                 }
-                void renewClaim().catch((error) => process.stderr.write(`Queue lease renewal failed: ${error?.message || error}\n`));
+                void renewClaim().catch((error) => logError(`Queue lease renewal failed: ${error?.message || error}\n`));
                 // Never renew lifecycle state from an old in-memory snapshot. The
                 // anchor may have disconnected since the claim began, which would
                 // otherwise resurrect a canonical stopped edge as running.
@@ -820,7 +821,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             queueMicrotask(() => void tryClaim(sessionId));
         }
         catch (error) {
-            process.stderr.write(`Queue dispatch failed for ${sessionId}: ${error?.message || error}\n`);
+            logError(`Queue dispatch failed for ${sessionId}: ${error?.message || error}\n`);
             const held = claims.get(sessionId);
             stopClaimRenewal(held);
             if (held?.entry && !held.entry.connection.closed) {
@@ -895,7 +896,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                         await reportHarness(sessionId, 'stopped', held?.entry || entry).catch(() => { });
                     }
                 });
-                process.stderr.write(`Anchor recovery failed for ${sessionId}: ${error?.message || error}\n`);
+                logError(`Anchor recovery failed for ${sessionId}: ${error?.message || error}\n`);
             });
         }
     };
@@ -1334,7 +1335,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                         // as their identity: a pane already showing them recognizes the
                         // refresh instead of being offered its own save as a new version.
                         contentEtag: String(edit.afterHash || ''),
-                    }).catch((error) => process.stderr.write(`Post-edit refresh failed for ${applied.path}: ${error?.message || error}\n`));
+                    }).catch((error) => logError(`Post-edit refresh failed for ${applied.path}: ${error?.message || error}\n`));
                 }
                 replyRpc.notify({
                     type: 'session.file.edit.result',
@@ -1420,7 +1421,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 void tryClaim(sessionId);
         }
         catch (error) {
-            process.stderr.write(`Queue registration failed: ${error?.message || error}\n`);
+            logError(`Queue registration failed: ${error?.message || error}\n`);
         }
         finally {
             registering.delete(control);
@@ -1439,7 +1440,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 void tryClaim(sessionId);
         }
         catch (error) {
-            process.stderr.write(`Machine heartbeat failed: ${error?.message || error}\n`);
+            logError(`Machine heartbeat failed: ${error?.message || error}\n`);
         }
     }
 }

package/dist/upload-sessions.js

@@ -6,6 +6,7 @@ import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import WebSocket from 'ws';
+import { logError, logInfo } from "./logging.js";
 import { streamDeepseekTrajectoryLines } from "./deepseek-trajectories.js";
 import { normalizeAllowedDirectories, workingDirectoryIsAllowed } from "./directory-policy.js";
 import { discoverGitAssociation } from "./git-association.js";
@@ -131,7 +132,7 @@ function reportingRedactor(tokens) {
             return;
         const rules = Object.fromEntries([...counts].sort((left, right) => right[1] - left[1]));
         counts.clear();
-        process.stderr.write(`Secret filtering applied (v${REDACTION_VERSION}): ${JSON.stringify(rules)}\n`);
+        logError(`Secret filtering applied (v${REDACTION_VERSION}): ${JSON.stringify(rules)}\n`);
     };
     const timer = setInterval(report, 60_000);
     timer.unref?.();
@@ -690,7 +691,7 @@ export async function connectUploader(options, machine, reconnect = false) {
         });
         try {
             const ready = await rpc.ready;
-            process.stdout.write(`${reconnect ? 'Reconnected' : 'Connected'} to ${options.url} as @${ready.user.login} ` +
+            logInfo(`${reconnect ? 'Reconnected' : 'Connected'} to ${options.url} as @${ready.user.login} ` +
                 `from ${os.hostname()} (${machine})\n`);
             return rpc;
         }
@@ -700,14 +701,14 @@ export async function connectUploader(options, machine, reconnect = false) {
                 authenticationRecoveries += 1;
                 const credentials = await options.credentialProvider.recover();
                 options.token = credentials.accessToken;
-                process.stderr.write('Uploader authentication was rejected; refreshed credentials.\n');
+                logError('Uploader authentication was rejected; refreshed credentials.\n');
                 attempt -= 1;
                 continue;
             }
             if (!isSocketError(error) || attempt === MAX_SOCKET_RETRIES)
                 throw error;
             const delay = reconnectDelay(attempt);
-            process.stderr.write(`  WebSocket connection failed: ${error.message}; retrying in ` +
+            logError(`  WebSocket connection failed: ${error.message}; retrying in ` +
                 `${(delay / 1000).toFixed(1)}s (${attempt + 1}/${MAX_SOCKET_RETRIES})\n`);
             await wait(delay);
         }
@@ -756,7 +757,7 @@ export class SharedUploaderConnection {
         this.reconnectTimer = setTimeout(() => {
             this.reconnectTimer = null;
             void this.current().catch((error) => {
-                process.stderr.write(`Shared uploader reconnect failed: ${error?.message || error}\n`);
+                logError(`Shared uploader reconnect failed: ${error?.message || error}\n`);
                 this.scheduleReconnect();
             });
         }, 1_000);
@@ -921,7 +922,7 @@ async function uploadFile(rpc, machine, root, capture, redactor = DEFAULT_REDACT
         }
         nextRow = Number(acknowledgement.nextRow);
         sent += batch.rows.length;
-        process.stdout.write(`  ${capture.relative}: ${nextRow}/${rows.length} rows · revision ${acknowledgement.revision}${acknowledgement.archived ? ' · archived' : ''}\n`);
+        logInfo(`  ${capture.relative}: ${nextRow}/${rows.length} rows · revision ${acknowledgement.revision}${acknowledgement.archived ? ' · archived' : ''}\n`);
     }
     return { rows: rows.length, sent, skipped: false };
 }
@@ -1372,7 +1373,7 @@ async function reportExternalManagement(rpc, machine, descriptors, previous = ne
         managedKeys = externallyManagedNativeDescriptorKeys(descriptors);
     }
     catch (error) {
-        process.stderr.write(`External ownership scan failed: ${error?.message || error}\n`);
+        logError(`External ownership scan failed: ${error?.message || error}\n`);
         return { rpc, managed: null };
     }
     const observedAt = new Date().toISOString();
@@ -1391,7 +1392,7 @@ async function reportExternalManagement(rpc, machine, descriptors, previous = ne
             });
         }
         catch (error) {
-            process.stderr.write(`External ownership upload failed: ${error?.message || error}\n`);
+            logError(`External ownership upload failed: ${error?.message || error}\n`);
             return { managed: null, previous };
         }
     }
@@ -1408,11 +1409,11 @@ async function watchExternalManagement(rpc, machine, getDescriptors) {
             previous = reported.previous;
             if (reported.managed !== null && reported.managed !== lastManagedCount) {
                 lastManagedCount = reported.managed;
-                process.stdout.write(`External ownership: ${reported.managed} managed session${reported.managed === 1 ? '' : 's'}\n`);
+                logInfo(`External ownership: ${reported.managed} managed session${reported.managed === 1 ? '' : 's'}\n`);
             }
         }
         catch (error) {
-            process.stderr.write(`External ownership watcher failed: ${error?.message || error}\n`);
+            logError(`External ownership watcher failed: ${error?.message || error}\n`);
         }
         await wait(NATIVE_WATCH_INTERVAL_MS);
     }
@@ -1456,9 +1457,9 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
     const byHarness = new Map();
     for (const session of initialSessions)
         byHarness.set(session.harness, (byHarness.get(session.harness) || 0) + 1);
-    process.stdout.write(`Native inventory: ${initialSessions.length} sessions across ${byHarness.size} harnesses\n`);
+    logInfo(`Native inventory: ${initialSessions.length} sessions across ${byHarness.size} harnesses\n`);
     for (const [harness, count] of [...byHarness].sort())
-        process.stdout.write(`  ${harness}: ${count}\n`);
+        logInfo(`  ${harness}: ${count}\n`);
     if (options.dryRun)
         return;
     const state = createNativeUploadState(options.nativeStateFile, machine);
@@ -1586,7 +1587,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
             stableSessionId: stableNativeSessionId,
             redactor,
         }).catch((error) => {
-            process.stderr.write(`Queue worker stopped unexpectedly: ${error?.stack || error}\n`);
+            logError(`Queue worker stopped unexpectedly: ${error?.stack || error}\n`);
         });
     }
     const totals = { current: 0, uploaded: 0, rows: 0, empty: 0, failed: 0 };
@@ -1623,7 +1624,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
             const message = error?.message || String(error);
             if (message !== uploadProgressError) {
                 uploadProgressError = message;
-                process.stderr.write(`Upload progress report failed: ${message}\n`);
+                logError(`Upload progress report failed: ${message}\n`);
             }
         }
     };
@@ -1685,7 +1686,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
                         cursor = {};
                         cursors.set(sessionId, cursor);
                         seen.delete(sessionId);
-                        process.stdout.write(`  ${descriptor.harness} ${descriptor.sourcePath}: reset for ${redactionUpgrade ? 'secret-filtered' : 'full'} replay\n`);
+                        logInfo(`  ${descriptor.harness} ${descriptor.sourcePath}: reset for ${redactionUpgrade ? 'secret-filtered' : 'full'} replay\n`);
                     }
                     result = await uploadNativeSession(rpc, machine, descriptor, cursor, (progress) => {
                         // Persist an explicitly incomplete fingerprint while a long replay
@@ -1693,7 +1694,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
                         // but the empty fingerprint still schedules the unfinished tail.
                         state.set(sessionId, '', cursor, REDACTION_VERSION);
                         scheduleUploadProgress();
-                        process.stdout.write(`  ${index + 1}/${changed.length} ${descriptor.harness}: ` +
+                        logInfo(`  ${index + 1}/${changed.length} ${descriptor.harness}: ` +
                             `${progress.nextRow}/${progress.total} rows` +
                             `${progress.archived ? ' · archived' : ''}\n`);
                     }, redactor, {
@@ -1717,7 +1718,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
                         failure = error;
                         break;
                     }
-                    process.stderr.write(`  ${index + 1}/${changed.length} ${descriptor.harness}: ${error.message}; ` +
+                    logError(`  ${index + 1}/${changed.length} ${descriptor.harness}: ${error.message}; ` +
                         `reconnecting (${attempt + 1}/${MAX_SOCKET_RETRIES})\n`);
                     rpc.close();
                     await wait(reconnectDelay(attempt));
@@ -1734,7 +1735,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
                     failures.delete(sessionId);
                     state.tombstone(sessionId);
                     totals.current += 1;
-                    process.stdout.write(`  ${index + 1}/${changed.length} ${descriptor.harness}: deleted on turns.dev\n`);
+                    logInfo(`  ${index + 1}/${changed.length} ${descriptor.harness}: deleted on turns.dev\n`);
                     scheduleUploadProgress();
                     continue;
                 }
@@ -1759,7 +1760,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
                     totals.rows += result.sent;
                 }
                 if (!result.skipped || (index + 1) % 50 === 0 || index + 1 === changed.length) {
-                    process.stdout.write(`  ${index + 1}/${changed.length} ${descriptor.harness} ${descriptor.sourcePath}: ` +
+                    logInfo(`  ${index + 1}/${changed.length} ${descriptor.harness} ${descriptor.sourcePath}: ` +
                         `${result.empty ? 'no conversation rows' : result.skipped ? `current (${result.rows} rows)` : `${result.sent} rows uploaded`}\n`);
                 }
                 scheduleUploadProgress();
@@ -1774,7 +1775,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
                     attempts,
                     retryAt: Date.now() + nativeFailureRetryDelay(attempts),
                 });
-                process.stderr.write(`  ${index + 1}/${changed.length} ${descriptor.harness} ${descriptor.sourcePath}: ${error?.message || error}\n`);
+                logError(`  ${index + 1}/${changed.length} ${descriptor.harness} ${descriptor.sourcePath}: ${error?.message || error}\n`);
                 scheduleUploadProgress();
             }
         }
@@ -1800,7 +1801,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
                 rememberInventory(sessions);
                 const unsettled = changedSessions();
                 if (unsettled.length) {
-                    process.stderr.write(`${unsettled.length} native sessions kept changing; run \`turns\` without --once to follow them continuously.\n`);
+                    logError(`${unsettled.length} native sessions kept changing; run \`turns\` without --once to follow them continuously.\n`);
                 }
                 break;
             }
@@ -1816,9 +1817,9 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
         await reportUploadProgress(true);
         rpc.close();
         totals.failed = failures.size;
-        process.stdout.write(`Native upload complete: ${JSON.stringify(totals)}\n`);
+        logInfo(`Native upload complete: ${JSON.stringify(totals)}\n`);
         if (failures.size) {
-            process.stderr.write(`${JSON.stringify({ failures: [...failures.values()] }, null, 2)}\n`);
+            logError(`${JSON.stringify({ failures: [...failures.values()] }, null, 2)}\n`);
             process.exitCode = 1;
         }
         return;
@@ -1962,7 +1963,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
         shutdown();
         process.exit(0);
     });
-    process.stdout.write(`Watching ${initialSessions.length} native sessions via ${nativeMonitor.count} directories; ` +
+    logInfo(`Watching ${initialSessions.length} native sessions via ${nativeMonitor.count} directories; ` +
         `polling known files every ${NATIVE_POLL_INTERVAL_MS / 1000}s and auditing every ` +
         `${NATIVE_DISCOVERY_INTERVAL_MS / 1000}s…\n`);
     let historicalSessionId = '';
@@ -1979,7 +1980,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
                 scheduleUploadProgress();
             }
             catch (error) {
-                process.stderr.write(`Native inventory refresh failed: ${error?.message || error}\n`);
+                logError(`Native inventory refresh failed: ${error?.message || error}\n`);
             }
         }
         const changed = changedSessions();
@@ -2064,7 +2065,7 @@ export async function runUploader(argv = process.argv.slice(2), { credentialProv
                 const result = await uploadFile(rpc, machine, options.runs, capture, filtering.redactor);
                 seen.set(capture.file, fingerprint);
                 if (result.skipped)
-                    process.stdout.write(`  ${capture.relative}: current (${result.rows} rows)\n`);
+                    logInfo(`  ${capture.relative}: current (${result.rows} rows)\n`);
             }
         };
         await sweep();
@@ -2072,7 +2073,7 @@ export async function runUploader(argv = process.argv.slice(2), { credentialProv
             rpc.close();
             return;
         }
-        process.stdout.write('Watching for appended capture rows…\n');
+        logInfo('Watching for appended capture rows…\n');
         for (;;) {
             await new Promise((resolve) => setTimeout(resolve, 2_000));
             await sweep();
@@ -2085,7 +2086,7 @@ export async function runUploader(argv = process.argv.slice(2), { credentialProv
 }
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
     runUploader().catch((error) => {
-        process.stderr.write(`${error?.stack || error}\n`);
+        logError(`${error?.stack || error}\n`);
         process.exitCode = 1;
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turns/dev",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",