crewx 0.8.9-rc.2 → 0.8.9-rc.21

package/dist-server/modules/crewx-pool.service.js

@@ -27,6 +27,7 @@ const workspace_event_bus_js_1 = require("../domain/events/workspace-event.bus.j
  *   2. CREWX_CONFIG env var (fallback when no workspace yaml found)
  *
  * Same workspace path → same Crewx instance (Map cache).
+ * Instances are lazily evicted when crewx.yaml mtime+size changes.
  * All instances are closed on application shutdown.
  *
  * Lifecycle: NestJS calls onApplicationShutdown() automatically.
@@ -36,6 +37,8 @@ let CrewxPoolService = class CrewxPoolService {
     eventBus;
     pool = new Map();
     poolMeta = new Map();
+    /** Orphaned metas: evicted while tasks were in-flight. Keyed by unique stamp. */
+    orphanedMetas = new Set();
     constructor(eventBus) {
         this.eventBus = eventBus;
     }
@@ -50,6 +53,23 @@ let CrewxPoolService = class CrewxPoolService {
         }
         return this.getForPath((0, workspace_context_store_js_1.getWorkspacePath)());
     }
+    /**
+     * Resolve the crewx.yaml config path for a workspace WITHOUT creating or
+     * caching a Crewx instance. Resolution policy (mirrors getForPath):
+     *   1. CREWX_CONFIG env → single shared file (pin)
+     *   2. <ws>/crewx.yaml → <ws>/crewx.yml (first existing)
+     *   3. CREWX_CONFIG fallback (undefined when neither yaml exists)
+     */
+    resolveConfigPath(workspacePath) {
+        const configPath = process.env.CREWX_CONFIG;
+        if (configPath)
+            return configPath;
+        const candidates = [
+            (0, path_1.join)(workspacePath, 'crewx.yaml'),
+            (0, path_1.join)(workspacePath, 'crewx.yml'),
+        ];
+        return candidates.find((p) => (0, fs_1.existsSync)(p)) ?? process.env.CREWX_CONFIG;
+    }
     /**
      * Return the Crewx instance for an explicit workspace path.
      * When CREWX_CONFIG is set, all paths resolve to a single shared instance
@@ -60,18 +80,71 @@ let CrewxPoolService = class CrewxPoolService {
         if (configPath) {
             return this.getOrCreate('__crewx_config__', configPath);
         }
-        const candidates = [
-            (0, path_1.join)(workspacePath, 'crewx.yaml'),
-            (0, path_1.join)(workspacePath, 'crewx.yml'),
-        ];
-        const yamlPath = candidates.find((p) => (0, fs_1.existsSync)(p))
-            ?? process.env.CREWX_CONFIG;
-        return this.getOrCreate(workspacePath, yamlPath);
+        return this.getOrCreate(workspacePath, this.resolveConfigPath(workspacePath));
+    }
+    /**
+     * Check whether the cached instance for the given key is stale relative
+     * to the config file on disk. Returns false when statSync fails (treat as
+     * unchanged) or when no entry exists in the pool.
+     *
+     * Public so that AGT.LIST can share the staleness judgement without
+     * triggering expensive instance creation.
+     */
+    isStale(key, configPath) {
+        if (!configPath)
+            return false;
+        const meta = this.poolMeta.get(key);
+        if (!meta)
+            return false;
+        const current = this.readFileStat(configPath);
+        if (!current)
+            return false; // statSync failed → treat as unchanged
+        return current.mtimeMs !== meta.fileStat.mtimeMs || current.size !== meta.fileStat.size;
     }
     invalidate(workspacePath) {
         const key = process.env.CREWX_CONFIG ? '__crewx_config__' : workspacePath;
         this.evict(key);
     }
+    readFileStat(filePath) {
+        try {
+            const s = (0, fs_1.statSync)(filePath);
+            return { mtimeMs: s.mtimeMs, size: s.size };
+        }
+        catch {
+            // File temporarily unavailable (editor rename, atomic write). Treat as unchanged.
+            return null;
+        }
+    }
+    /**
+     * Lazy evict: remove from pool Map immediately so the next request starts
+     * fresh, but defer unsub + close() on the old instance until all in-flight
+     * tasks complete (refcount reaches 0).
+     *
+     * We intentionally keep event listeners alive on the orphaned instance so
+     * that task:end can decrement refcount and trigger close when it hits 0.
+     */
+    lazyEvict(key) {
+        const meta = this.poolMeta.get(key);
+        const existing = this.pool.get(key);
+        // Remove from active maps so next getOrCreate starts fresh.
+        this.pool.delete(key);
+        this.poolMeta.delete(key);
+        if (!existing)
+            return;
+        if (!meta || meta.refcount <= 0) {
+            // No in-flight tasks — unsub and close immediately.
+            meta?.unsub();
+            existing.then((c) => c.close()).catch(() => { });
+        }
+        else {
+            // In-flight tasks: keep event listeners alive so task:end can fire.
+            // Mark meta as orphaned so task:end can find it.
+            meta.orphanedInstance = existing;
+            this.orphanedMetas.add(meta);
+            // checkOrphanedClose is called from task:end handler via orphanedMetas.
+        }
+    }
+    /** Explicit (immediate) evict — used by invalidate() triggered by UI writes. */
     evict(key) {
         const meta = this.poolMeta.get(key);
         if (meta) {
@@ -85,14 +158,54 @@ let CrewxPoolService = class CrewxPoolService {
         }
     }
     getOrCreate(key, configPath) {
+        // Check staleness for existing entry — evict lazily if config changed.
+        if (this.pool.has(key) && configPath) {
+            if (this.isStale(key, configPath)) {
+                this.lazyEvict(key);
+            }
+        }
         if (!this.pool.has(key)) {
+            // Capture mtime BEFORE createServerCrewx to prevent TOCTOU self-perpetuation.
+            const capturedStat = configPath
+                ? (this.readFileStat(configPath) ?? { mtimeMs: 0, size: 0 })
+                : { mtimeMs: 0, size: 0 };
             const instancePromise = (0, crewx_server_js_1.createServerCrewx)(configPath, this.eventBus);
             this.pool.set(key, instancePromise);
             // Wire up SDK event subscriptions after the instance resolves.
-            instancePromise.then((crewx) => this.wireEvents(key, crewx)).catch(() => { });
+            instancePromise
+                .then((crewx) => {
+                try {
+                    this.wireEvents(key, crewx, capturedStat);
+                }
+                catch {
+                    // wireEvents failed (e.g. crewx.on not available in tests/stubs).
+                    // Ensure poolMeta is at least set so shutdown cleanup works.
+                    if (!this.poolMeta.has(key)) {
+                        this.poolMeta.set(key, {
+                            unsub: () => { },
+                            poolKey: key,
+                            fileStat: capturedStat,
+                            refcount: 0,
+                        });
+                    }
+                }
+            })
+                .catch(() => {
+                // If creation failed, remove from pool so a subsequent request retries.
+                this.pool.delete(key);
+                this.poolMeta.delete(key);
+            });
         }
         return this.pool.get(key);
     }
+    checkOrphanedClose(meta) {
+        if (meta.refcount <= 0 && meta.orphanedInstance) {
+            // All in-flight tasks have finished — safe to unsub listeners and close.
+            meta.unsub();
+            meta.orphanedInstance.then((c) => c.close()).catch(() => { });
+            this.orphanedMetas.delete(meta);
+        }
+    }
     /**
      * Subscribe to task:start / task:end / task:output on a newly created Crewx instance and
      * fan-out task.created / task.updated / task.logged events to WorkspaceEventBus.
@@ -100,9 +213,7 @@ let CrewxPoolService = class CrewxPoolService {
      * threadId for task.updated is read from task:end metadata (propagated by SDK from task:start).
      * threadId for task.logged is enriched from threadIdByTask (task:output has no threadId).
      */
-    wireEvents(key, crewx) {
-        if (!this.eventBus)
-            return;
+    wireEvents(key, crewx, capturedStat) {
         const bus = this.eventBus;
         const wsId = crewx.workspaceId;
         // task.logged: taskId → threadId (populated on task:start, cleared on task:end)
@@ -112,25 +223,39 @@ let CrewxPoolService = class CrewxPoolService {
         const THROTTLE_MS = 200;
         // Hard cap: evict oldest entry when exceeded (guards against missed task:end on crash)
         const MAX_TASK_ENTRIES = 500;
+        // Create meta object first so event handlers can reference it directly
+        // (avoids stale poolMeta.get(key) after a lazy evict replaces the entry).
+        const meta = {
+            unsub: () => { }, // filled in below after handlers are registered
+            poolKey: key,
+            fileStat: capturedStat,
+            refcount: 0,
+        };
         const unsubStart = crewx.on('task:start', (e) => {
+            // Increment refcount directly on the captured meta (not via Map lookup).
+            meta.refcount++;
             threadIdByTask.set(e.traceId, e.threadId ?? '');
             if (threadIdByTask.size > MAX_TASK_ENTRIES) {
                 const oldest = threadIdByTask.keys().next().value;
                 if (oldest !== undefined)
                     threadIdByTask.delete(oldest);
             }
-            bus.emit(wsId, {
-                type: 'task.created',
-                data: {
-                    taskId: e.traceId,
-                    threadId: e.threadId ?? '',
-                    agent: e.agentRef,
-                    status: 'running',
-                    updatedAt: e.timestamp.toISOString(),
-                },
-            });
+            if (bus) {
+                bus.emit(wsId, {
+                    type: 'task.created',
+                    data: {
+                        taskId: e.traceId,
+                        threadId: e.threadId ?? '',
+                        agent: e.agentRef,
+                        status: 'running',
+                        updatedAt: e.timestamp.toISOString(),
+                    },
+                });
+            }
         });
         const unsubOutput = crewx.on('task:output', (e) => {
+            if (!bus)
+                return;
             const taskId = e.traceId;
             if (throttleByTask.has(taskId))
                 return; // absorb within 200ms window
@@ -145,42 +270,50 @@ let CrewxPoolService = class CrewxPoolService {
         });
         const unsubEnd = crewx.on('task:end', (e) => {
             const taskId = e.traceId;
-            // flush pending task.logged before emitting task.updated
-            const timer = throttleByTask.get(taskId);
-            if (timer !== undefined) {
-                clearTimeout(timer);
-                throttleByTask.delete(taskId);
+            if (bus) {
+                // flush pending task.logged before emitting task.updated
+                const timer = throttleByTask.get(taskId);
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                    throttleByTask.delete(taskId);
+                    bus.emit(wsId, {
+                        type: 'task.logged',
+                        data: { taskId, threadId: threadIdByTask.get(taskId) ?? '' },
+                    });
+                }
+                threadIdByTask.delete(taskId);
+                const threadId = e.metadata?.threadId ?? '';
                 bus.emit(wsId, {
-                    type: 'task.logged',
-                    data: { taskId, threadId: threadIdByTask.get(taskId) ?? '' },
+                    type: 'task.updated',
+                    data: {
+                        taskId: e.traceId,
+                        threadId,
+                        agent: e.agentRef,
+                        status: e.error ? 'failed' : 'success',
+                        ...(e.error ? { error: e.error.message } : {}),
+                        ...(e.costUsd != null ? { costUsd: e.costUsd } : {}),
+                        updatedAt: e.timestamp.toISOString(),
+                    },
                 });
             }
-            threadIdByTask.delete(taskId);
-            const threadId = e.metadata?.threadId ?? '';
-            bus.emit(wsId, {
-                type: 'task.updated',
-                data: {
-                    taskId: e.traceId,
-                    threadId,
-                    agent: e.agentRef,
-                    status: e.error ? 'failed' : 'success',
-                    ...(e.error ? { error: e.error.message } : {}),
-                    ...(e.costUsd != null ? { costUsd: e.costUsd } : {}),
-                    updatedAt: e.timestamp.toISOString(),
-                },
-            });
-        });
-        this.poolMeta.set(key, {
-            unsub: () => {
-                unsubStart();
-                unsubOutput();
-                unsubEnd();
-                for (const t of throttleByTask.values())
-                    clearTimeout(t);
-                throttleByTask.clear();
-                threadIdByTask.clear();
-            },
+            // Decrement refcount on the captured meta directly.
+            meta.refcount = Math.max(0, meta.refcount - 1);
+            // If this meta has been orphaned (lazy evict), trigger deferred close.
+            if (meta.orphanedInstance) {
+                this.checkOrphanedClose(meta);
+            }
         });
+        // Wire unsub into the meta object now that handlers are registered.
+        meta.unsub = () => {
+            unsubStart();
+            unsubOutput();
+            unsubEnd();
+            for (const t of throttleByTask.values())
+                clearTimeout(t);
+            throttleByTask.clear();
+            threadIdByTask.clear();
+        };
+        this.poolMeta.set(key, meta);
     }
     async onApplicationShutdown() {
         // Unsubscribe all SDK listeners before closing instances.
@@ -188,6 +321,14 @@ let CrewxPoolService = class CrewxPoolService {
             meta.unsub();
         }
         this.poolMeta.clear();
+        // Unsub and close any orphaned instances (deferred close from lazy evict).
+        for (const orphan of this.orphanedMetas) {
+            orphan.unsub();
+            if (orphan.orphanedInstance) {
+                orphan.orphanedInstance.then((c) => c.close()).catch(() => { });
+            }
+        }
+        this.orphanedMetas.clear();
         await Promise.all([...this.pool.values()].map((p) => p.then((c) => c.close()).catch(() => { })));
     }
 };

package/dist-server/repository/task.repository.js

@@ -135,7 +135,7 @@ let TaskRepository = class TaskRepository extends base_sqlite_repository_js_1.Ba
             provider: 'cli',
             input_tokens: r.inputTokens,
             output_tokens: r.outputTokens,
-            total_tokens: r.inputTokens + r.outputTokens,
+            total_tokens: r.totalTokens,
             total_cost: r.costUsd,
             task_count: r.totalTasks,
             active_duration_ms: 0,
@@ -153,6 +153,10 @@ let TaskRepository = class TaskRepository extends base_sqlite_repository_js_1.Ba
             output_tokens: r.outputTokens,
         }));
     }
+    /** USG.PROVIDER: Aggregate per-provider usage within a date range. */
+    getProviderUsage(from, to, workspace) {
+        return this.sdk.getProviderUsage(from, to, workspace);
+    }
     /** Find a task by id with workspace isolation for stop operation. */
     findTaskForStop(taskId, workspaceId) {
         const row = this.sdk.findTaskForStop(taskId, workspaceId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewx",
-  "version": "0.8.9-rc.2",
+  "version": "0.8.9-rc.21",
   "description": "CrewX — AI agent team dashboard with Electron UI and CLI (Web + Electron + Global CLI)",
   "main": "server.js",
   "bin": {
@@ -50,6 +50,8 @@
     "class-validator": "0.15.1",
     "cookie-parser": "1.4.7",
     "date-fns": "^4.3.0",
+    "dom-anchor-text-position": "^5.0.0",
+    "dom-anchor-text-quote": "^4.0.2",
     "dotenv": "17.2.3",
     "elkjs": "^0.11.1",
     "execa": "8.0.1",
@@ -78,20 +80,20 @@
     "wink-nlp-utils": "2.1.0",
     "yargs": "17.7.0",
     "zod": "3.25.76",
-    "@crewx/cli": "0.8.9-rc.2",
-    "@crewx/chromex": "0.1.0",
-    "@crewx/doc": "0.1.8",
-    "@crewx/dreaming": "0.1.0",
-    "@crewx/cron": "0.1.10",
-    "@crewx/memory": "0.1.23",
-    "@crewx/knowledge-core": "0.1.17",
-    "@crewx/shared": "0.0.5",
-    "@crewx/sdk": "0.8.9-rc.2",
-    "@crewx/wi": "0.1.10",
-    "@crewx/search": "0.1.10",
-    "@crewx/workflow": "0.3.22",
+    "@crewx/cli": "0.8.9-rc.21",
+    "@crewx/cron": "0.1.10-rc.55",
+    "@crewx/chromex": "0.1.0-rc.57",
+    "@crewx/dreaming": "0.1.0-rc.39",
+    "@crewx/doc": "0.1.9-rc.19",
+    "@crewx/knowledge-core": "0.1.17-rc.16",
+    "@crewx/sdk": "0.8.9-rc.21",
+    "@crewx/memory": "0.1.23-rc.37",
+    "@crewx/search": "0.1.10-rc.20",
+    "@crewx/shared": "0.0.6-rc.8",
+    "@crewx/wbs": "0.1.10-rc.50",
     "@crewx/skill": "0.1.20",
-    "@crewx/wbs": "0.1.10"
+    "@crewx/workflow": "0.3.22-rc.37",
+    "@crewx/wi": "0.1.10-rc.21"
   },
   "devDependencies": {
     "@ccusage/codex": "0.0.1",

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

@@ -237,7 +237,7 @@ Examples:
   crewx agent
   crewx agent ls
   crewx agent ls --role=PM
-  crewx agent ls --team="CrewX Core 개발팀"
+  crewx agent ls --team="CrewX Core Team"
   crewx agent ls --provider=claude
   crewx agent ls --role=PM --provider=claude
   crewx agent ls --role=PM,general

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

@@ -13,6 +13,8 @@ export interface InitResult {
     skippedReason?: 'yaml-exists';
     workspaceId?: string;
     slug?: string;
+    statusLineConfigured?: boolean;
+    statusLineSkipped?: boolean;
 }
 /**
  * Programmatic init — creates crewx.yaml, support dirs, and optionally installs hooks.