Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

Keep routine refusals and handled states off stderr

[._.]/ Adam Eivy20ad5ad3806e
diff --git a/AGENTS.md b/AGENTS.md
index fc8b071150..7570f890a8 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -253,7 +253,7 @@ This policy governs code comments, not user-facing guides or product copy.
console.log(`🚀 Server started on port ${PORT}`);
console.error(`❌ Failed to connect: ${err.message}`);
```
- **The marker picks the stream.** A failure line (`❌`/`⛔`) goes to `console.error`, a deliberate refusal or skip to `console.warn`, and only progress/success stays on `console.log` — a failure on stdout is invisible to every stderr-based monitor. For a mixed status line, choose the sink first (`const log = ok ? console.log : console.error;`) rather than branching the emoji alone. `server/logLevelConventions.test.js` scans the whole server tree for this and carries no allowlist.
+ **stderr means "investigate".** `console.error` and `console.warn` are reserved for something actually wrong — a code/workflow bug, a broken invariant, an unexpected failure — that warrants an investigation agent or a GitHub issue. A failure line (`❌`/`⛔`) goes to `console.error`; `console.warn` is for a recoverable anomaly that is still a defect worth tracing. Everything a working system does on purpose stays on `console.log` with a non-failure marker: a guard's refusal or a 4xx answer (`🚫`), a deliberate skip or dedupe (`⏭️`), an expected degraded state it handles (iCloud eviction, a peer on another schema version, a provider quota, a reconnect/retry), slow-path telemetry (`🐢`), and advice re-announced on a schedule. If a line fires on a normal day, it does not belong on stderr. For a mixed status line, choose the sink first (`const log = ok ? console.log : console.error;`) rather than branching the emoji alone. `server/logLevelConventions.test.js` scans the whole server tree so a failure marker never lands on stdout and carries no allowlist; the reverse (a routine line on stderr) is judgment the scan cannot make.
- **LLM response merging — distinguish absent vs intentionally empty.** "Key absent" preserves the original; "key present with empty value" applies the clear. Don't use `.length` truthiness as the signal. Strings: `null`/`undefined` = absent, `""` = a clear (server helpers like `universeBuilderExpand.trimField` return `null` for non-strings). Arrays/objects: gate on `Array.isArray(parsed?.field)` / `parsed?.field !== null && typeof parsed?.field === 'object' && !Array.isArray(parsed.field)` before falling back. Keep server-side merges and the client's `pick` helpers mirrored.
- **Sentinel + validate to distinguish "not set / failed" from "present-but-empty / valid".** Never let *absent*, *failed-to-fetch*, or *invalid* collapse into the same value as *fetched-and-legitimately-empty* or *valid*; use an explicit sentinel and validate before falling through, not `x.length` or `x || fallback`. Canonical examples in the local-LLM backends: model-list caches use `null = not fetched` vs `[] = cached-empty` (`ollamaManager.js` `installedModels`, `lmStudioManager.js` `availableModels`); `getBackend()` validates the `.env` marker before falling back to `process.env` (`server/services/localLlm.js`); a reachable-but-list-failed backend surfaces an explicit `modelsError` rather than `0 models` (`lmStudioManager.js` `getLastListError`).
diff --git a/server/lib/errorHandler.js b/server/lib/errorHandler.js
index d9026c9302..f1d4733256 100644
--- a/server/lib/errorHandler.js
+++ b/server/lib/errorHandler.js
@@ -182,6 +182,13 @@ const summarizeDetails = (details) => {
return clampLogText(details);
};
+/**
+ * stderr means "investigate" (root AGENTS.md). A 4xx is the server refusing a
+ * request (validation, auth, not-found, a guard's 409): an answered request, so
+ * stdout. Only a 5xx or a `critical` error is a fault and reaches stderr.
+ */
+const isServerFault = (error) => error.status >= 500 || error.severity === 'critical';
+
/**
* Handle rejected route promises with logging, Socket.IO events and the shared
* HTTP error envelope; delegate failures after streaming starts to middleware.
@@ -203,22 +210,23 @@ export function asyncHandler(fn) {
// Log the error (skip stack traces for upstream platform issues)
const route = `${req.method} ${routePath(req)}`;
const suffix = causeSuffix(error);
- const logMsg = `❌ Route error [${route}]: ${errorMessage(error)}${suffix}`;
if (error.code === 'PLATFORM_UNAVAILABLE') {
- console.warn(`⚠️ Platform unavailable [${route}]: ${error.message}${suffix}`);
+ // An upstream outage, not a defect here — the response already says so.
+ console.log(`🌩️ Platform unavailable [${route}]: ${error.message}${suffix}`);
} else if (error.severity === 'warning') {
// Expected high-volume 404s (e.g. speculative media-job archive
// lookups) — already classified as benign; don't pollute server logs.
- } else if (error.status >= 500) {
+ } else if (isServerFault(error)) {
// Use the original Error's stack (from before normalization) when available
// so diagnostics point to the actual throwing function, not normalizeError.
const stack = error.originalStack || error.stack;
- console.error(logMsg, stack ? stack : '');
+ console.error(`❌ Route error [${route}]: ${errorMessage(error)}${suffix}`, stack ? stack : '');
} else {
// An empty `[]`/`{}` is truthy but summarizes to nothing — gate on the
// summary so the line can't end in a dangling colon.
const summary = error.context?.details ? summarizeDetails(error.context.details) : '';
- console.error(summary ? `${logMsg}: ${summary}` : logMsg);
+ const logMsg = `🚫 Route refused [${route}] ${error.status}: ${errorMessage(error)}${suffix}`;
+ console.log(summary ? `${logMsg}: ${summary}` : logMsg);
}
return sendErrorResponse(res, error, { io });
@@ -443,12 +451,11 @@ export function errorMiddleware(err, req, res, next) {
// Log the error
const route = `${req.method} ${routePath(req)}`;
- const logMsg = `❌ Server error [${route}]: ${errorMessage(error)}${causeSuffix(error)}`;
- if (error.status >= 500) {
- console.error(logMsg);
+ if (isServerFault(error)) {
+ console.error(`❌ Server error [${route}]: ${errorMessage(error)}${causeSuffix(error)}`);
if (err.stack) console.error(err.stack);
} else {
- console.error(logMsg);
+ console.log(`🚫 Server refused [${route}] ${error.status}: ${errorMessage(error)}${causeSuffix(error)}`);
}
// Emit the socket event and send the shared envelope — synchronous handlers
diff --git a/server/lib/errorHandler.test.js b/server/lib/errorHandler.test.js
index 7636538d8d..f0d1d31ea5 100644
--- a/server/lib/errorHandler.test.js
+++ b/server/lib/errorHandler.test.js
@@ -379,6 +379,7 @@ describe('errorHandler.js', () => {
// spy into sibling tests.
let noopErrorListener;
let errorSpy;
+ let logSpy;
let testListeners;
// Register an errorEvents 'error' listener that this describe will remove.
const trackListener = (fn) => { testListeners.push(fn); errorEvents.on('error', fn); };
@@ -388,11 +389,13 @@ describe('errorHandler.js', () => {
noopErrorListener = () => {};
errorEvents.on('error', noopErrorListener);
errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+ logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
});
afterEach(() => {
errorEvents.off('error', noopErrorListener);
for (const fn of testListeners) errorEvents.off('error', fn);
errorSpy.mockRestore();
+ logSpy.mockRestore();
});
it('catches a thrown ServerError, emits, and responds with status + body', async () => {
@@ -513,8 +516,8 @@ describe('errorHandler.js', () => {
})(req, res, vi.fn());
await flushMicrotasks();
- expect(errorSpy).toHaveBeenCalledTimes(1);
- const [line, ...extraArgs] = errorSpy.mock.calls[0];
+ expect(logSpy).toHaveBeenCalledTimes(1);
+ const [line, ...extraArgs] = logSpy.mock.calls[0];
expect(extraArgs).toEqual([]);
expect(line).not.toContain('\n');
expect(line).not.toContain('[{');
@@ -538,7 +541,7 @@ describe('errorHandler.js', () => {
})(req, res, vi.fn());
await flushMicrotasks();
- const line = errorSpy.mock.calls[0][0];
+ const line = logSpy.mock.calls[0][0];
expect(line).not.toContain('\n');
expect(line).toContain('pg_dump: error: connection to server failed');
expect(line).not.toContain('trailing');
@@ -554,7 +557,34 @@ describe('errorHandler.js', () => {
})(req, res, vi.fn());
await flushMicrotasks();
- expect(errorSpy.mock.calls[0][0]).toBe('❌ Route error [GET /api/thing]: Validation failed');
+ expect(logSpy.mock.calls[0][0]).toBe('🚫 Route refused [GET /api/thing] 400: Validation failed');
+ });
+
+ // stderr is reserved for faults worth investigating: a 4xx is the server
+ // refusing a request (a guard's 409, validation, not-found), so it stays on
+ // stdout unless the thrower marked it critical.
+ it('routes a 4xx refusal to stdout and only 5xx/critical to stderr', async () => {
+ const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+ try {
+ for (const status of [400, 404, 409]) {
+ await asyncHandler(async () => { throw new ServerError('kept', { status }); })(makeReqRes(null).req, makeReqRes(null).res, vi.fn());
+ }
+ await flushMicrotasks();
+ expect(errorSpy).not.toHaveBeenCalled();
+ expect(warnSpy).not.toHaveBeenCalled();
+ expect(logSpy.mock.calls.map(([line]) => line)).toEqual([
+ '🚫 Route refused [GET /api/thing] 400: kept',
+ '🚫 Route refused [GET /api/thing] 404: kept',
+ '🚫 Route refused [GET /api/thing] 409: kept',
+ ]);
+
+ await asyncHandler(async () => { throw new ServerError('bad', { status: 409, severity: 'critical' }); })(makeReqRes(null).req, makeReqRes(null).res, vi.fn());
+ await flushMicrotasks();
+ expect(errorSpy).toHaveBeenCalledTimes(1);
+ expect(errorSpy.mock.calls[0][0]).toBe('❌ Route error [GET /api/thing]: bad');
+ } finally {
+ warnSpy.mockRestore();
+ }
});
// The 500 branch logs the stack, not `details` — it must stay untouched.
@@ -616,7 +646,7 @@ describe('errorHandler.js', () => {
})(req, res, vi.fn());
await flushMicrotasks();
- const line = errorSpy.mock.calls[0][0];
+ const line = logSpy.mock.calls[0][0];
expect(line).not.toContain('[object Object]');
expect(line).toContain('ahead=[{"universe":"core","version":13}]');
expect(line).toContain('behind=[]');
@@ -638,8 +668,8 @@ describe('errorHandler.js', () => {
})(req, res, vi.fn());
await flushMicrotasks();
- expect(errorSpy).toHaveBeenCalledTimes(1);
- const line = errorSpy.mock.calls[0][0];
+ expect(logSpy).toHaveBeenCalledTimes(1);
+ const line = logSpy.mock.calls[0][0];
expect(line).toContain('bad=[unserializable]');
});
});
diff --git a/server/logLevelConventions.test.js b/server/logLevelConventions.test.js
index a7cbe5fcf2..32aacaf480 100644
--- a/server/logLevelConventions.test.js
+++ b/server/logLevelConventions.test.js
@@ -24,7 +24,9 @@
* violation. Route it by what actually happened:
*
* - a genuine failure → `console.error`
- * - a deliberate refusal/skip → `console.warn`
+ * - a recoverable defect worth tracing → `console.warn`
+ * - a deliberate refusal/skip → `console.log` with a non-failure marker
+ * (stderr means "investigate" — root `AGENTS.md`)
* - a mixed success/failure line (a ternary status message) → pick the sink
* first and log through it: `const log = ok ? console.log : console.error;`
*
@@ -58,9 +60,10 @@
*
* There is none for the failure-stream rule, on purpose. Every site in the tree passes; a new violation is
* a bug to fix, not an entry to add. If you are reading this because the scan
- * just failed, change `console.log` to `console.error` (or `console.warn` for a
- * refusal) on the named line. An `emitLog` hit is the level argument, not the
- * wrapper: `'error'` for a failure, `'warn'` for a refusal or skip (#12576).
+ * just failed, either the line reports a fault — change `console.log` to
+ * `console.error` — or it reports a deliberate refusal/skip, and the fix is to
+ * replace the failure marker, not the stream. An `emitLog` hit is the level
+ * argument, not the wrapper: `'error'` for a failure (#12576).
*
* ## What this guard CANNOT see
*
diff --git a/server/services/agentLifecycle.js b/server/services/agentLifecycle.js
index da6c2b974f..489901dd66 100644
--- a/server/services/agentLifecycle.js
+++ b/server/services/agentLifecycle.js
@@ -90,7 +90,7 @@ export async function spawnAgentForTask(task) {
return null;
}
if (outcome === SPAWN_DEDUP_SKIP) {
- console.warn(`⚠️ Task ${task.id} is already being spawned — ignoring this dequeue`);
+ console.log(`⏭️ Task ${task.id} is already being spawned — ignoring this dequeue`);
return null;
}
return outcome;
diff --git a/server/services/agentProviderResolution.js b/server/services/agentProviderResolution.js
index 2505587b28..1d2f8bc91c 100644
--- a/server/services/agentProviderResolution.js
+++ b/server/services/agentProviderResolution.js
@@ -212,7 +212,9 @@ async function resolveOrdinaryProviderAndModel(task) {
const providerAvailable = isProviderAvailable(provider.id);
if (!providerAvailable) {
const status = getProviderStatus(provider.id);
- emitLog('warn', `Provider ${provider.id} unavailable: ${status.message}`, {
+ // A sidelined provider (quota, cooldown) is handled by the fallback below;
+ // only the no-fallback path is a failure.
+ emitLog('info', `⏸️ Provider ${provider.id} unavailable: ${status.message}`, {
taskId: task.id,
providerId: provider.id,
reason: status.reason
diff --git a/server/services/bootstrap.js b/server/services/bootstrap.js
index 490242cbc7..5a67f36b7d 100644
--- a/server/services/bootstrap.js
+++ b/server/services/bootstrap.js
@@ -1069,7 +1069,8 @@ const withGrace = (label, ms, run) => new Promise((resolve) => {
const finish = (msg) => complete(msg, console.log);
const finishWithError = (msg, error) => complete(msg, console.error, error);
run({ finish, finishWithError });
- setTimeout(() => finishWithError(`⚠️ ${label} close exceeded ${ms}ms — proceeding`), ms).unref?.();
+ // Expected on most restarts (lingering upgraded sockets); the bounded wait is the handling.
+ setTimeout(() => finish(`⏱️ ${label} close exceeded ${ms}ms — proceeding`), ms).unref?.();
});
// graceMs is deliberately bounded: this runs after the request drain's deadline,
diff --git a/server/services/bootstrap.shutdown.test.js b/server/services/bootstrap.shutdown.test.js
index c25e1f28a3..3b9b16c3f1 100644
--- a/server/services/bootstrap.shutdown.test.js
+++ b/server/services/bootstrap.shutdown.test.js
@@ -194,11 +194,11 @@ describe('bounded server shutdown', () => {
await vi.advanceTimersByTimeAsync(1);
await closing;
expect(settled).toHaveBeenCalledTimes(1);
- expect(error.mock.calls).toEqual([['⚠️ HTTP server close exceeded 1000ms — proceeding']]);
+ expect(log.mock.calls).toEqual([['⏱️ HTTP server close exceeded 1000ms — proceeding']]);
onClose();
onClose(new Error('late failure'));
- expect(log).not.toHaveBeenCalled();
- expect(error).toHaveBeenCalledTimes(1);
+ expect(log).toHaveBeenCalledTimes(1);
+ expect(error).not.toHaveBeenCalled();
});
});
diff --git a/server/services/branchReconcileCompletion.js b/server/services/branchReconcileCompletion.js
index 7f12c9c439..915ce2aff2 100644
--- a/server/services/branchReconcileCompletion.js
+++ b/server/services/branchReconcileCompletion.js
@@ -63,7 +63,8 @@ export async function settleBranchReconcileRun(agent) {
const uncertain = unverifiedRetirements.length > 0 || result.forgeUnavailable || result.prStateUnavailable
|| result.worktreeInventory == null || result.orphanRemotes?.remoteUnavailable;
const remaining = inFlightBranches.size + holds.remaining.length;
- emitLog(uncertain || remaining ? 'warn' : 'info',
+ // Branches left to live owners are the normal outcome; only an incomplete scan is an anomaly.
+ emitLog(uncertain ? 'warn' : 'info',
`Branch reconciliation completion: cleaned ${result.cleaned.length}, superseded ${result.reapedSuperseded?.length || 0}, remaining ${remaining}${uncertain ? '; scan incomplete' : ''}`,
{ appId: app.id, analysisType: type, counts: holds.counts, skipCauses: holds.skipCauses });
return result;
diff --git a/server/services/branchReconcileCompletion.test.js b/server/services/branchReconcileCompletion.test.js
index f73c25f336..21f124ded3 100644
--- a/server/services/branchReconcileCompletion.test.js
+++ b/server/services/branchReconcileCompletion.test.js
@@ -61,7 +61,7 @@ describe('branch reconciliation completion', () => {
claimMarkersHeld: [{ branch: 'claim/issue-42', issue: 42, reason: 'claim-reservation-owner-unverified' }],
});
await settleBranchReconcileRun(agent);
- expect(emitLog).toHaveBeenLastCalledWith('warn', expect.stringContaining('remaining 3'), expect.objectContaining({
+ expect(emitLog).toHaveBeenLastCalledWith('info', expect.stringContaining('remaining 3'), expect.objectContaining({
counts: { heldBranches: 1, heldDetached: 1, heldClaims: 1 },
skipCauses: { 'worktree-locked': 1, 'checkout-retained': 1, 'claim-reservation-owner-unverified': 1 },
}));
@@ -77,7 +77,7 @@ describe('branch reconciliation completion', () => {
],
});
await settleBranchReconcileRun(agent);
- expect(emitLog).toHaveBeenLastCalledWith('warn', expect.stringContaining('remaining 2'), expect.objectContaining({
+ expect(emitLog).toHaveBeenLastCalledWith('info', expect.stringContaining('remaining 2'), expect.objectContaining({
counts: { heldBranches: 1, heldDetached: 0, heldBackMerged: 1 },
skipCauses: { 'worktree-locked': 1 },
}));
diff --git a/server/services/cos.js b/server/services/cos.js
index 80acd904c5..9142311b5e 100644
--- a/server/services/cos.js
+++ b/server/services/cos.js
@@ -513,7 +513,8 @@ async function bootDaemon(state) {
if (learningInsights?.recommendations?.length > 0) {
const recommendations = learningInsights.recommendations.slice(0, 3);
for (const rec of recommendations) {
- const level = rec.type === 'warning' ? 'warn' : rec.type === 'action' ? 'info' : 'debug';
+ // A recommendation is advice re-announced every cycle, not a fault — stdout only.
+ const level = rec.type === 'warning' || rec.type === 'action' ? 'info' : 'debug';
emitLog(level, `🧠 Learning: ${rec.message}`, { recommendationType: rec.type });
}
cosEvents.emit('learning:recommendations', {
diff --git a/server/services/cosRunnerClient.js b/server/services/cosRunnerClient.js
index 687d0cbb44..7a86381dd4 100644
--- a/server/services/cosRunnerClient.js
+++ b/server/services/cosRunnerClient.js
@@ -153,7 +153,7 @@ export function initCosRunnerConnection() {
socket.on('connect_error', (err) => {
if (connectErrorLogged) return;
connectErrorLogged = true;
- console.error(`🔌 CoS Runner connection error: ${err.message} — retrying until it answers`);
+ console.log(`🔌 CoS Runner connection error: ${err.message} — retrying until it answers`);
});
// Forward events to registered handlers
diff --git a/server/services/cosState.js b/server/services/cosState.js
index bbc84b3866..9df913c7a9 100644
--- a/server/services/cosState.js
+++ b/server/services/cosState.js
@@ -81,7 +81,7 @@ export function withStateLock(fn) {
} finally {
const { totalMs, lagMs, lagMaxMs } = span.end();
if (totalMs >= SLOW_STATE_OPERATION_MS) {
- console.warn(`🐢 CoS state queue slow hold heldMs=${totalMs} waitMs=${waitMs} loopLagMs=${lagMs} loopLagMaxMs=${lagMaxMs}`);
+ console.log(`🐢 CoS state queue slow hold heldMs=${totalMs} waitMs=${waitMs} loopLagMs=${lagMs} loopLagMaxMs=${lagMaxMs}`);
}
}
});
@@ -726,7 +726,7 @@ export async function saveState(state, { onStage, changedAgentIds } = {}) {
const summary = span.end();
if (summary.totalMs >= SLOW_STATE_OPERATION_MS) {
const ms = (name) => summary.phases[name]?.ms ?? 0;
- console.warn(`🐢 CoS state write slow outcome=${outcome} totalMs=${summary.totalMs} prepareMs=${ms('prepare')} agentsMs=${ms('agents')} serializeMs=${ms('serialize')} writeMs=${ms('write')} replaceMs=${ms('replace')} dirSyncMs=${ms('dirSync')} loopLagMs=${summary.lagMs} loopLagMaxMs=${summary.lagMaxMs} sizeKiB=${Math.round(bytes / 1024)}`);
+ console.log(`🐢 CoS state write slow outcome=${outcome} totalMs=${summary.totalMs} prepareMs=${ms('prepare')} agentsMs=${ms('agents')} serializeMs=${ms('serialize')} writeMs=${ms('write')} replaceMs=${ms('replace')} dirSyncMs=${ms('dirSync')} loopLagMs=${summary.lagMs} loopLagMaxMs=${summary.lagMaxMs} sizeKiB=${Math.round(bytes / 1024)}`);
}
}
stateCache = stampGeneration(state, stateRecovery);
diff --git a/server/services/cosState.test.js b/server/services/cosState.test.js
index bdde061301..f74bc40095 100644
--- a/server/services/cosState.test.js
+++ b/server/services/cosState.test.js
@@ -489,7 +489,7 @@ describe('state operation slow diagnostics', () => {
const store = await freshModule();
const clock = __createManualClock();
store.__setCosStateDiagnosticsClockForTests(clock);
- const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+ const warn = vi.spyOn(console, 'log').mockImplementation(() => {});
try {
const stages = [];
await store.saveState(await store.loadState(), { onStage: (stage) => {
diff --git a/server/services/cosTaskGenerator.js b/server/services/cosTaskGenerator.js
index ffaa315102..0889014808 100644
--- a/server/services/cosTaskGenerator.js
+++ b/server/services/cosTaskGenerator.js
@@ -1328,7 +1328,7 @@ export async function queueEligibleImprovementTasks(state, cosTaskData, {
const appBusy = appsWithPendingImprovement.has(app.id);
if (appBusy && cronTasks.length === 0) {
if (appsWithBlockedImprovement.has(app.id)) {
- emitLog('warn', `⛔ Skipping improvement queue for ${app.name}: failure-blocked improvement task ${appsWithBlockedImprovement.get(app.id)} occupies the app slot — resolve or delete it to resume`, { appId: app.id });
+ emitLog('info', `⏸️ Skipping improvement queue for ${app.name}: failure-blocked improvement task ${appsWithBlockedImprovement.get(app.id)} occupies the app slot — resolve or delete it to resume`, { appId: app.id });
} else {
emitLog('debug', `App ${app.name} already has a pending improvement task — skipping queue`);
}
diff --git a/server/services/dataSync.js b/server/services/dataSync.js
index 1e93876079..dc7ca3e272 100644
--- a/server/services/dataSync.js
+++ b/server/services/dataSync.js
@@ -1353,8 +1353,8 @@ export async function applyRemote(category, remoteData, options = {}) {
const fullDiff = compareSchemaVersions(senderSchemaVersions, PORTOS_SCHEMA_VERSIONS);
const versionDiff = scopeVersionDiff(fullDiff, SNAPSHOT_CATEGORY_SCHEMA_KEYS[category] || []);
if (versionDiff.ahead.length > 0) {
- console.warn(
- `⚠️ dataSync: rejecting "${category}" snapshot — ${formatVersionGap(versionDiff)} ` +
+ console.log(
+ `⏸️ dataSync: rejecting "${category}" snapshot — ${formatVersionGap(versionDiff)} ` +
`(sender PortOS ${senderPortosVersion || 'unknown'})`,
);
return {
diff --git a/server/services/mortalLoomStore.js b/server/services/mortalLoomStore.js
index 3ebec60430..fd87512af2 100644
--- a/server/services/mortalLoomStore.js
+++ b/server/services/mortalLoomStore.js
@@ -387,7 +387,7 @@ function warnEvictedOnce(detail) {
const now = Date.now();
if (now - lastEvictedWarnAt < EVICTED_WARN_INTERVAL_MS) return;
lastEvictedWarnAt = now;
- console.warn(`⚠️ MortalLoom store evicted from local storage; ${detail}`);
+ console.log(`☁️ MortalLoom store evicted from local storage; ${detail}`);
}
async function readStoreAtPathResult(path) {
diff --git a/server/services/obsidian.js b/server/services/obsidian.js
index b377e5ac70..91acacbe1f 100644
--- a/server/services/obsidian.js
+++ b/server/services/obsidian.js
@@ -202,7 +202,7 @@ export async function detectVaults() {
async function readNoteContent(fullPath, skipped) {
return readIfMaterialized(fullPath, { label: 'Obsidian note' }).catch((err) => {
if (err.code === ICLOUD_NOT_MATERIALIZED) {
- console.warn(`⚠️ Obsidian note evicted from local storage; skipping: ${fullPath}`);
+ console.log(`☁️ Obsidian note evicted from local storage; skipping: ${fullPath}`);
if (skipped) skipped.count += 1;
return null;
}
diff --git a/server/services/sharing/peerSyncPush.js b/server/services/sharing/peerSyncPush.js
index 441a887917..9a1f8065bb 100644
--- a/server/services/sharing/peerSyncPush.js
+++ b/server/services/sharing/peerSyncPush.js
@@ -345,8 +345,8 @@ export async function pushRecordToPeer(sub, options = {}) {
peerPortosVersion: typeof details.receiverPortosVersion === 'string' ? details.receiverPortosVersion : null,
peerSchemaVersions: isPlainObject(details.receiverSchemaVersions) ? details.receiverSchemaVersions : null,
});
- console.warn(
- `⚠️ peerSync: ${peer.name || peer.instanceId} rejected push — peer is on an older PortOS schema. ` +
+ console.log(
+ `⏸️ peerSync: ${peer.name || peer.instanceId} rejected push — peer is on an older PortOS schema. ` +
`Re-tries will pause until they upgrade. ${formatVersionGap({ ahead: details.ahead || [], behind: details.behind || [] })}`,
);
return { pushed: false, reason: 'peer-schema-behind', blockedBySchema: true };
diff --git a/server/services/sharing/peerSyncReceive.js b/server/services/sharing/peerSyncReceive.js
index 8be2540f23..350ddbfab7 100644
--- a/server/services/sharing/peerSyncReceive.js
+++ b/server/services/sharing/peerSyncReceive.js
@@ -257,8 +257,8 @@ async function assertSchemaVersionGate({ kind, record, issues, linkedCollection,
const versionDiff = scopeVersionDiff(fullDiff, [...relevantCategories]);
const catalogBehind = versionDiff.behind.some((gap) => gap.category === 'catalog');
if (versionDiff.ahead.length > 0 || catalogBehind) {
- console.warn(
- `⚠️ peerSync: rejecting push from ${sourceInstanceId} — ${formatVersionGap(versionDiff)} (sender PortOS ${senderPortosVersion || 'unknown'})`,
+ console.log(
+ `⏸️ peerSync: rejecting push from ${sourceInstanceId} — ${formatVersionGap(versionDiff)} (sender PortOS ${senderPortosVersion || 'unknown'})`,
);
// Surface the receiver's PortOS version so the sender can show the user
// *which* version their peer is on (the label the user thinks of as "the
diff --git a/server/services/subAgentSpawner.js b/server/services/subAgentSpawner.js
index 662d0f1442..fbc024a073 100644
--- a/server/services/subAgentSpawner.js
+++ b/server/services/subAgentSpawner.js
@@ -313,7 +313,7 @@ async function runInitSpawner() {
// otherwise still announce "resuming held agent tasks" and drive a dequeue
// cycle into a runner that is gone again. A reconnect re-arms it.
clearTimeout(reconnectDequeueTimer);
- emitLog('warn', '⏸️ CoS Runner disconnected — staying in runner mode, holding agent tasks until it returns');
+ emitLog('info', '⏸️ CoS Runner disconnected — staying in runner mode, holding agent tasks until it returns');
});
onCosRunnerEvent('connection:ready', () => {