crewx 0.9.0-rc.111 → 0.9.0-rc.112

package/bin/crewx-ui.js

@@ -53,12 +53,6 @@ if (isElectron || isOverlay) {
     ? join(__dirname, '..', 'dist-electron', 'overlay.js')
     : join(__dirname, '..', 'dist-electron', 'main.js');
 
-  if (process.env.ELECTRON_RUN_AS_NODE) {
-    console.warn(
-      '[crewx-ui] Ignoring ELECTRON_RUN_AS_NODE for Electron UI launch (it forces Electron into Node mode).',
-    );
-  }
-
   const child = spawn(String(electronPath), [entryFile], {
     stdio: 'inherit',
     env: getElectronSpawnEnv(),

package/bin/crewx.js

@@ -55,12 +55,6 @@ function launchElectron(entryFile, routeArgs = []) {
     return false; // Electron not installed
   }
 
-  if (process.env.ELECTRON_RUN_AS_NODE) {
-    console.warn(
-      '[crewx] Ignoring ELECTRON_RUN_AS_NODE for Electron UI launch (it forces Electron into Node mode).',
-    );
-  }
-
   const child = spawn(String(electronPath), [entryFile, ...routeArgs], {
     stdio: 'inherit',
     env: getElectronSpawnEnv(),

package/dist-server/common/task-log/public-log-projection.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OUTPUT_UNAVAILABLE = void 0;
 exports.isProviderProtocolOnlyText = isProviderProtocolOnlyText;
+exports.parsePublicStdoutLogEntries = parsePublicStdoutLogEntries;
 exports.isUnsupportedStructuredInfoLog = isUnsupportedStructuredInfoLog;
 exports.createOutputUnavailableLogEntry = createOutputUnavailableLogEntry;
 exports.projectPublicTaskLogEntry = projectPublicTaskLogEntry;
@@ -25,6 +26,34 @@ const STRUCTURED_INFO_LOG_TYPES = new Set([
 function isProviderProtocolOnlyText(message, adapterKey) {
     return (0, sdk_1.isProtocolOnlyText)(message, adapterKey);
 }
+/**
+ * Classify one persisted stdout row before the shared log pipeline runs.
+ *
+ * Displayable adapter output always wins. A confirmed Claude metadata line is
+ * omitted before merge, truncation, and log-tail slicing so protocol chatter
+ * cannot consume the public log budget. All other protocol-only rows retain
+ * the existing content-free placeholder and uncertain input remains raw text.
+ */
+function parsePublicStdoutLogEntries(timestamp, message, adapterKey) {
+    let parsed = [];
+    try {
+        parsed = (0, sdk_1.parseStdoutEvent)(timestamp, message, adapterKey);
+    }
+    catch {
+        // Preserve the historical raw-text fallback when an adapter parser fails.
+    }
+    if (parsed.length > 0)
+        return parsed;
+    // Metadata classification is intentionally opt-in. Without a registered
+    // adapter key, do not infer that an otherwise protocol-shaped line is safe
+    // to drop.
+    if (adapterKey && (0, sdk_1.isMetadataOnlyProtocolLine)(message, adapterKey))
+        return [];
+    if ((0, sdk_1.isProtocolOnlyText)(message, adapterKey)) {
+        return [createOutputUnavailableLogEntry(timestamp)];
+    }
+    return [{ timestamp, type: 'text', content: message }];
+}
 /**
  * Return true for a JSON ACP/info message whose type is outside the accepted
  * structured activity allowlist. Plain info text and untyped JSON remain text.

package/dist-server/domain/cron/cron-bootstrap.service.js

@@ -64,8 +64,10 @@ const DEFAULT_LEGACY_TERM_TIMEOUT_MS = 1_000;
 const DEFAULT_LEGACY_POLL_INTERVAL_MS = 50;
 // macOS `ps lstart` is second-granularity while the plain legacy PID marker
 // has millisecond mtime. This is only a coarse PID-reuse guard, not proof of
-// process creation identity; keep its tolerance bounded to one second.
-const PROCESS_START_IDENTITY_TOLERANCE_MS = 1_000;
+// process creation identity. `ps lstart` is quantized down to whole seconds,
+// so only the marker-write-after-start direction is valid. Keep the window
+// bounded to one quantization second plus one marker-write second.
+const PROCESS_START_IDENTITY_MAX_DELTA_MS = 2_000;
 const EXPECTED_COMMAND_UNAVAILABLE_REASON = 'expected full process command is unavailable';
 /** Nest token for injectable host seams used by tests and embedders. */
 var cron_runtime_sync_port_js_2 = require("./cron-runtime-sync.port.js");
@@ -423,7 +425,8 @@ function startIdentitiesMatch(marker, processStart) {
     const markerNumber = typeof marker === 'number' ? marker : Number(marker);
     const processNumber = typeof processStart === 'number' ? processStart : Number(processStart);
     if (Number.isFinite(markerNumber) && Number.isFinite(processNumber)) {
-        return Math.abs(markerNumber - processNumber) <= PROCESS_START_IDENTITY_TOLERANCE_MS;
+        const delta = markerNumber - processNumber;
+        return delta >= 0 && delta <= PROCESS_START_IDENTITY_MAX_DELTA_MS;
     }
     return String(marker) === String(processStart);
 }
@@ -729,6 +732,12 @@ let CronBootstrapService = CronBootstrapService_1 = class CronBootstrapService {
                 alert: 'expected-command-unavailable',
             };
         }
+        if (process.platform === 'win32') {
+            // Win32_Process does not provide a trusted cwd in the default
+            // inspector. Do not apply the Unix ps/lstart numeric window to an
+            // injected observation that happens to include a cwd.
+            return { kind: 'unknown', reason: 'process cwd is not trustworthy on Windows' };
+        }
         if (!observation.commandLine)
             return { kind: 'unknown', reason: 'process command line is unknown' };
         const daemonKind = classifyCronDaemonCommand(observation.commandLine);

package/dist-server/domain/task/task.service.js

@@ -1247,23 +1247,7 @@ let TaskService = TaskService_1 = class TaskService {
         const entries = [];
         for (const log of rawLogs) {
             if (log.level === 'stdout') {
-                let parsed = [];
-                try {
-                    parsed = (0, sdk_1.parseStdoutEvent)(log.timestamp, log.message, providerId);
-                }
-                catch { /* adapter parse failure — classify the raw row below */ }
-                if (parsed.length > 0) {
-                    entries.push(...parsed);
-                    continue;
-                }
-                // Parsed successfully but no displayable entries (e.g. thinking-only assistant message).
-                // Keep a safe row for confirmed provider protocol envelopes instead of
-                // exposing the raw JSON fallback.
-                if ((0, public_log_projection_js_1.isProviderProtocolOnlyText)(log.message, providerId)) {
-                    entries.push((0, public_log_projection_js_1.createOutputUnavailableLogEntry)(log.timestamp));
-                    continue;
-                }
-                entries.push({ timestamp: log.timestamp, type: 'text', content: log.message });
+                entries.push(...(0, public_log_projection_js_1.parsePublicStdoutLogEntries)(log.timestamp, log.message, providerId));
             }
             else if (log.level === 'info') {
                 const infoEntries = (0, sdk_1.defaultParseEvent)(log.message, log.timestamp);

package/dist-server/domain/thread/thread.service.js

@@ -1123,23 +1123,7 @@ let ThreadService = ThreadService_1 = class ThreadService {
         const entries = [];
         for (const log of rawLogs) {
             if (log.level === 'stdout') {
-                let parsed = [];
-                try {
-                    parsed = (0, sdk_1.parseStdoutEvent)(log.timestamp, log.message, providerId);
-                }
-                catch { /* adapter parse failure — classify the raw row below */ }
-                if (parsed.length > 0) {
-                    entries.push(...parsed);
-                    continue;
-                }
-                // Parsed successfully but no displayable entries (e.g. thinking-only assistant message).
-                // Keep a safe row for confirmed provider protocol envelopes instead of
-                // exposing the raw JSON fallback.
-                if ((0, public_log_projection_js_1.isProviderProtocolOnlyText)(log.message, providerId)) {
-                    entries.push((0, public_log_projection_js_1.createOutputUnavailableLogEntry)(log.timestamp));
-                    continue;
-                }
-                entries.push({ timestamp: log.timestamp, type: 'text', content: log.message });
+                entries.push(...(0, public_log_projection_js_1.parsePublicStdoutLogEntries)(log.timestamp, log.message, providerId));
             }
             else if (log.level === 'info') {
                 const infoEntries = (0, sdk_1.defaultParseEvent)(log.message, log.timestamp);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewx",
-  "version": "0.9.0-rc.111",
+  "version": "0.9.0-rc.112",
   "description": "CrewX — AI agent team dashboard with Electron UI and CLI (Web + Electron + Global CLI)",
   "main": "server.js",
   "bin": {
@@ -150,20 +150,20 @@
     "ws": "8.20.0",
     "yargs": "17.7.0",
     "zod": "3.25.76",
-    "@crewx/chromex": "0.1.0-rc.144",
-    "@crewx/cli": "0.9.0-rc.111",
-    "@crewx/cron": "0.1.10-rc.146",
-    "@crewx/doc": "0.1.9-rc.104",
-    "@crewx/dreaming": "0.1.0-rc.137",
-    "@crewx/memory": "0.1.23-rc.128",
-    "@crewx/knowledge-core": "0.1.17-rc.121",
-    "@crewx/search": "0.1.10-rc.107",
-    "@crewx/sdk": "0.9.0-rc.111",
-    "@crewx/shared": "0.0.6-rc.26",
-    "@crewx/skill": "0.1.20-rc.5",
-    "@crewx/wbs": "0.1.10-rc.137",
-    "@crewx/workflow": "0.3.22-rc.157",
-    "@crewx/wi": "0.1.10-rc.131"
+    "@crewx/chromex": "0.1.0-rc.145",
+    "@crewx/cli": "0.9.0-rc.112",
+    "@crewx/cron": "0.1.10-rc.147",
+    "@crewx/dreaming": "0.1.0-rc.138",
+    "@crewx/knowledge-core": "0.1.17-rc.122",
+    "@crewx/doc": "0.1.9-rc.105",
+    "@crewx/memory": "0.1.23-rc.129",
+    "@crewx/shared": "0.0.6-rc.27",
+    "@crewx/search": "0.1.10-rc.108",
+    "@crewx/skill": "0.1.20-rc.6",
+    "@crewx/sdk": "0.9.0-rc.112",
+    "@crewx/workflow": "0.3.22-rc.158",
+    "@crewx/wi": "0.1.10-rc.132",
+    "@crewx/wbs": "0.1.10-rc.138"
   },
   "devDependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.2.132",

package/packages/cli/dist/commands/detached.js

@@ -293,6 +293,9 @@ function runnerCommand(command) {
 function buildRunnerEnvironment(taskId) {
     const env = { ...process.env };
     delete env[INTERNAL_TOKEN_ENV];
+    if (process.versions.electron) {
+        env.ELECTRON_RUN_AS_NODE = '1';
+    }
     env.CREWX_DETACHED_RUNNER = '1';
     env.CREWX_ASSIGNED_TASK_ID = taskId;
     return env;
@@ -328,6 +331,9 @@ function readAssignedTaskActor(taskRepo, taskId) {
 }
 function buildMiddleEnvironment(token) {
     const env = { ...process.env };
+    if (process.versions.electron) {
+        env.ELECTRON_RUN_AS_NODE = '1';
+    }
     env[INTERNAL_TOKEN_ENV] = token;
     return env;
 }

package/packages/cli/dist/commands/doctor.d.ts

@@ -6,6 +6,7 @@
  *   crewx doctor                  Run full diagnosis
  *   crewx doctor --config <path>  Use specific config file
  */
+import type { CrewxExecutableResolution, CrewxExecutableStage } from '@crewx/sdk';
 interface DiagnosticResult {
     name: string;
     status: 'success' | 'warning' | 'error';
@@ -44,6 +45,25 @@ export interface CrewxShimReport {
         fingerprint: string;
     }>;
 }
+export interface CrewxExecutableReport {
+    platform: NodeJS.Platform;
+    pathCandidates: string[];
+    stage?: CrewxExecutableStage;
+    argv?: string[];
+    electron: boolean;
+    requiredEnvKeys: string[];
+    binResolution: 'global_first' | 'local_first';
+    adoptedPath?: string;
+    resolutionError?: string;
+}
+export interface CrewxExecutableInspectionOptions {
+    platform?: NodeJS.Platform;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    binResolution?: 'global_first' | 'local_first';
+    pathCandidates?: readonly string[];
+    resolution?: CrewxExecutableResolution;
+}
 /** CLI diagnostics keyed by the bare provider name used in PROVIDER_ORDER. */
 export declare const CLI_PROVIDER_INFO: Record<string, CliProviderInfo>;
 /** Format a byte count for diagnostic output. */
@@ -52,6 +72,10 @@ export declare function formatBytes(bytes: number): string;
 export declare function inspectNpxCache(cacheRoot?: string): NpxCacheReport;
 /** Inspect installed CrewX hooks without rewriting provider settings. */
 export declare function inspectHookCommands(projectRoot: string): HookCommandReport;
+/** Inspect the SDK-selected CrewX executable without printing environment values. */
+export declare function inspectCrewxExecutable(options?: CrewxExecutableInspectionOptions & {
+    configPath?: string;
+}): CrewxExecutableReport;
 /** Inspect orphaned CrewX PATH shim directories without modifying them. */
 export declare function inspectCrewxShims(crewxHome?: string, resolvedFingerprint?: string | undefined): CrewxShimReport;
 /**

package/packages/cli/dist/commands/doctor.js

@@ -12,10 +12,10 @@ exports.CLI_PROVIDER_INFO = void 0;
 exports.formatBytes = formatBytes;
 exports.inspectNpxCache = inspectNpxCache;
 exports.inspectHookCommands = inspectHookCommands;
+exports.inspectCrewxExecutable = inspectCrewxExecutable;
 exports.inspectCrewxShims = inspectCrewxShims;
 exports.checkCliProviders = checkCliProviders;
 exports.handleDoctor = handleDoctor;
-const node_crypto_1 = require("node:crypto");
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
@@ -255,17 +255,98 @@ function inspectHookCommands(projectRoot) {
     }
     return { inspectedFiles, issues };
 }
-function currentShimFingerprint() {
-    const resolution = (0, sdk_1.resolveCrewxExecutable)();
-    if (!resolution.ok)
-        return undefined;
-    return (0, node_crypto_1.createHash)('sha256')
-        .update(JSON.stringify(resolution.argv))
-        .digest('hex')
-        .slice(0, 16);
+function configuredBinResolution(configPath, fallback = 'global_first') {
+    try {
+        const config = (0, sdk_1.loadYamlFile)(configPath);
+        const value = config.settings?.bin_resolution;
+        return value === 'local_first' || value === 'global_first' ? value : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+function readWindowsCrewxPathCandidates(cwd, env, platform) {
+    if (platform !== 'win32')
+        return [];
+    try {
+        (0, sdk_1.primeWindowsConsoleCodePage)();
+        const output = (0, node_child_process_1.execFileSync)('where.exe', ['crewx'], {
+            cwd,
+            env,
+            encoding: null,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return (0, sdk_1.decodeConsoleBuffer)(output, { platform })
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+/** Inspect the SDK-selected CrewX executable without printing environment values. */
+function inspectCrewxExecutable(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const cwd = (0, node_path_1.resolve)(options.cwd ?? process.cwd());
+    const env = options.env ?? process.env;
+    const configPath = options.configPath ?? (0, node_path_1.join)(cwd, 'crewx.yaml');
+    const resolution = options.resolution ?? (0, sdk_1.resolveCrewxExecutable)({ env, cwd, platform });
+    const pathCandidates = options.pathCandidates
+        ? [...options.pathCandidates]
+        : readWindowsCrewxPathCandidates(cwd, env, platform);
+    const requiredEnvKeys = resolution.ok
+        ? Object.keys(resolution.requiredEnv ?? {})
+            .filter((key) => key === 'ELECTRON_RUN_AS_NODE')
+        : [];
+    return {
+        platform,
+        pathCandidates,
+        ...(resolution.ok
+            ? {
+                stage: resolution.stage,
+                argv: [...resolution.argv],
+                adoptedPath: resolution.argv[0],
+            }
+            : { resolutionError: resolution.reason }),
+        electron: requiredEnvKeys.includes('ELECTRON_RUN_AS_NODE'),
+        requiredEnvKeys,
+        binResolution: options.binResolution ?? configuredBinResolution(configPath),
+    };
+}
+function checkCrewxExecutable(report) {
+    const details = [
+        `platform: ${report.platform}`,
+        `stage: ${report.stage ?? '(unresolved)'}`,
+        `argv: ${report.argv ? (0, sdk_1.formatCrewxExecutableArgv)(report.argv) : '(unresolved)'}`,
+        `adopted path: ${report.adoptedPath ?? '(none)'}`,
+        `Electron runtime: ${report.electron ? 'yes' : 'no'}`,
+        `required environment keys: ${report.requiredEnvKeys.length > 0 ? report.requiredEnvKeys.join(', ') : '(none)'}`,
+        `bin_resolution setting: ${report.binResolution}`,
+        ...(report.platform === 'win32'
+            ? [`where.exe crewx candidates: ${report.pathCandidates.length > 0 ? report.pathCandidates.join(', ') : '(none)'}`]
+            : []),
+    ];
+    if (report.resolutionError) {
+        return {
+            name: 'CrewX Executable',
+            status: 'warning',
+            message: 'Could not resolve the CrewX executable',
+            details: `${details.join('\n')}\nResolution failed; no environment values were printed.`,
+        };
+    }
+    return {
+        name: 'CrewX Executable',
+        status: 'success',
+        message: 'SDK child executable contract is available',
+        details: details.join('\n'),
+    };
 }
 /** Inspect orphaned CrewX PATH shim directories without modifying them. */
-function inspectCrewxShims(crewxHome = (0, sdk_1.getCrewxHome)(), resolvedFingerprint = currentShimFingerprint()) {
+function inspectCrewxShims(crewxHome = (0, sdk_1.getCrewxHome)(), resolvedFingerprint = (() => {
+    const resolution = (0, sdk_1.resolveCrewxExecutable)();
+    return resolution.ok ? (0, sdk_1.crewxCliShimFingerprint)(resolution) : undefined;
+})()) {
     const shimRoot = (0, node_path_1.join)((0, node_path_1.resolve)(crewxHome), 'bin-shim');
     const staleDirectories = [];
     if (resolvedFingerprint) {
@@ -526,6 +607,7 @@ async function handleDoctor(args) {
     let shims = inspectCrewxShims();
     const projectRoot = (0, node_path_1.dirname)((0, node_path_1.resolve)(configPath));
     const hooks = inspectHookCommands(projectRoot);
+    const executable = inspectCrewxExecutable({ configPath, cwd: process.cwd() });
     if (cleanNpxCache) {
         cleanDoctorArtifacts(npxCache, shims);
         npxCache = inspectNpxCache();
@@ -535,6 +617,7 @@ async function handleDoctor(args) {
         checkConfig(configPath),
         checkLogsDir(),
         checkEnvVars(),
+        checkCrewxExecutable(executable),
         ...checkCliProviders(),
         checkNpxCache(npxCache),
         checkHookCommands(hooks),

package/packages/cli/dist/commands/hook/install.js

@@ -32,9 +32,26 @@ function resolveCrewxBinary() {
     if (!resolution.ok) {
         throw new Error((0, sdk_1.formatCrewxExecutableFailure)(resolution));
     }
-    const stableEntrypoint = (0, sdk_1.materializeCrewxStableEntrypoint)(resolution);
-    const useStable = stableEntrypoint && resolution.argv.some(sdk_1.isRotatingInstallPath);
-    return (0, sdk_1.formatCrewxExecutableArgv)(useStable ? [stableEntrypoint] : resolution.argv);
+    let stableEntrypoint;
+    try {
+        stableEntrypoint = (0, sdk_1.materializeCrewxStableEntrypoint)(resolution, { allowEnvStage: true });
+    }
+    catch (error) {
+        if (resolution.requiredEnv && Object.keys(resolution.requiredEnv).length > 0) {
+            throw new Error(`CrewX hook entrypoint could not preserve required environment: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        throw error;
+    }
+    if (stableEntrypoint) {
+        return (0, sdk_1.formatCrewxExecutableArgv)([stableEntrypoint]);
+    }
+    // A required runtime environment cannot be represented by a raw argv string,
+    // and the fingerprint shim directory is doctor-GC managed. Refuse to write
+    // either representation when the stable hook path was not eligible.
+    if (resolution.requiredEnv && Object.keys(resolution.requiredEnv).length > 0) {
+        throw new Error('CrewX hook entrypoint could not preserve required environment: stable entrypoint is not eligible for this executable');
+    }
+    return (0, sdk_1.formatCrewxExecutableArgv)(resolution.argv);
 }
 function readSettingsTyped(settingsPath) {
     return (0, paths_1.readSettings)(settingsPath);

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewx/cli",
-  "version": "0.9.0-rc.111",
+  "version": "0.9.0-rc.112",
   "license": "UNLICENSED",
   "engines": {
     "node": ">=20.19.0"