@nowcrew/daemon 0.6.102-beta.3 → 0.6.102-beta.5

package/README.md

@@ -434,23 +434,27 @@ path-free inventory and logical `(projectId, skillName)` bindings. The local pat
 while an add command is forwarded to the selected online Computer; it is not written to the workspace
 database, structured logs, inventory frames, or responses. Project Skills are disabled on Windows.
 
-One binding set is projected into both Runtime discovery layouts:
+Skill entries may be real directories or directory symlinks, including relative, absolute, chained,
+and shared directories outside the project. Only direct, non-hidden entries are scanned. Broken,
+cyclic, inaccessible, and non-directory links count as invalid Skills without hiding healthy entries;
+the existing frontmatter, size, name-conflict, and inventory limits apply to linked Skills too.
+
+Each execution projects its binding set into a private Runtime discovery directory:
 
 ```text
-<agentsRoot>/<handle>/.agents/skills/<name>                         # Codex symlink
-<agentsRoot>/<handle>/.crew/claude-skills/.claude/skills/<name>    # Claude symlink
+<agentsRoot>/<handle>/.crew/project-skills/exec-<executionId>/runtime/.claude/skills/<name>
 ```
 
-The two complete directories switch under one per-Agent reconcile/launch lock. A failed switch restores
-the prior complete projection; a missing project or Skill removes only that link and does not block other
-work. These are ordinary writable symlinks, not snapshots or a sandbox: an Agent running as the daemon
-user can modify the source Skill through them. That write-through risk is intentionally accepted.
+The scanner retains the entry path. Binding checks and execution startup resolve its current real
+directory and check for `SKILL.md`; missing sources warn and are omitted without blocking other work.
+Each execution links to that resolved directory, so retargeting an entry affects subsequent executions
+while active executions keep their original target. Source file edits remain live. The projection is
+removed after the runtime process tree stops; source directories and user-created links are preserved.
+These are ordinary writable symlinks, not snapshots or a sandbox: an Agent running as the daemon user
+can modify the source Skill through them. That write-through risk is intentionally accepted.
 
-Codex protocol-v1 task directories are opaque
-`<agentsRoot>/<handle>/tasks/<safe-prefix>-<sha256>` paths. The daemon writes `.nowwork-root` at the Agent
-root and adds it to Codex `project_root_markers`, so upward discovery reaches `.agents/skills` without
-changing the task cwd. Claude receives
-`--add-dir <agentsRoot>/<handle>/.crew/claude-skills`; Claude treats those Skills as `projectSettings`,
+Codex registers the execution's `runtime/.claude/skills` through `skills/extraRoots/set`. Claude receives
+the execution's `runtime` directory through `--add-dir`; Claude treats those Skills as `projectSettings`,
 so a machine policy that disables project settings also disables this source even when the projection is
 healthy.
 
@@ -467,10 +471,10 @@ scope is merged. The policy version in Codex's session fingerprint cold-starts o
 once, then subsequent runs can resume normally. Explicit `shell_environment_policy.set` entries, shell
 startup scripts and Agent notes remain separate configuration; this change does not correct them.
 
-Binding changes reconcile immediately when the Computer is online. On reconnect the server sends the
-complete binding set for every Agent assigned to that Computer, including empty sets that clear stale
-links left by offline unbinds. Every non-empty execution snapshot is also reconciled immediately before
-Runtime launch, which recovers from a missed notification or daemon restart. Skill file content changes
+Binding changes are checked immediately when the Computer is online. On reconnect the server sends the
+complete binding set for every Agent assigned to that Computer, including empty sets. Each execution
+uses its server-snapshotted binding set and revalidates local source paths immediately before Runtime
+launch. Skill file content changes
 are visible through the symlink immediately; adding, deleting, renaming, or changing frontmatter requires
 a rescan. Web descriptions remain at the last inventory value until that rescan.
 

package/dist/automatic-daemon-installer.js

@@ -6,7 +6,8 @@ import { assertProfileAgentsRootUnique, listProfiles, loadProfile, MachineTokenS
 import { buildServiceSpec, captureExactService, hardenWindowsProfile, replaceExactService, restoreExactService, serviceAction, serviceStatus, systemCommandRunner, uninstallService, } from "./computer-service.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { buildManagedServiceRecord, installManagedService, uninstallManagedService, } from "./managed-service-lifecycle.js";
-import { ManagedServiceConflictError, managedServiceConflict, managedServiceIdentityMatches, readManagedServiceRegistry, } from "./managed-service-registry.js";
+import { readManagedServiceRegistry, } from "./managed-service-registry.js";
+import { captureManagedServiceForSetup } from "./automatic-service-capture.js";
 import { resolveAutomaticInstallTarget, } from "./automatic-install-target.js";
 import { acquireDaemonInstallationLease, } from "./daemon-installation-lease.js";
 import { daemonVersion } from "./machine-info.js";
@@ -80,7 +81,6 @@ function defaultDependencies() {
         },
         captureService: async (spec, target) => {
             if (platform !== "win32") {
-                managedRecords = await readManagedServiceRegistry({ userHome, localHome: localHomeForTarget(target, platform) });
                 const entryPath = spec.daemonCommand[1];
                 const installation = daemonGlobalInstallation(entryPath, platform);
                 if (installation === null) {
@@ -94,14 +94,13 @@ function defaultDependencies() {
                     entryPath,
                     ...installation,
                 });
-                const { generation: _generation, createdAt: _createdAt, ...expected } = candidate;
-                previousManagedRecord = managedRecords.find((record) => managedServiceIdentityMatches(record, expected));
-                if (previousManagedRecord === undefined) {
-                    const conflict = managedServiceConflict(managedRecords, candidate);
-                    if (conflict !== null) {
-                        throw new ManagedServiceConflictError(conflict.resource, candidate, conflict.owner);
-                    }
-                }
+                const captured = await captureManagedServiceForSetup({
+                    spec, record: candidate, runner,
+                    registry: { userHome, localHome: localHomeForTarget(target, platform) },
+                });
+                managedRecords = captured.managedRecords;
+                previousManagedRecord = captured.previousManagedRecord;
+                return captured.snapshot;
             }
             return captureExactService(spec, runner);
         },
@@ -175,7 +174,12 @@ function defaultDependencies() {
                 ? localHome
                 : localHomeForNpmPrefix(previousManagedRecord.npmPrefix, platform);
             const current = (await readManagedServiceRegistry({ userHome, localHome: restoreLocalHome })).find((record) => record.serviceId === spec.id);
-            if (current !== undefined && JSON.stringify(current) !== JSON.stringify(previousManagedRecord)) {
+            const onlyHashChanged = current !== undefined && previousManagedRecord !== undefined
+                && JSON.stringify({ ...current, descriptorSha256: previousManagedRecord.descriptorSha256 })
+                    === JSON.stringify(previousManagedRecord);
+            // Preflight may have captured the exact descriptor while leaving a stale
+            // registry hash untouched. Let installManagedService reconcile it in place.
+            if (current !== undefined && !onlyHashChanged && JSON.stringify(current) !== JSON.stringify(previousManagedRecord)) {
                 await uninstallManagedService({
                     spec,
                     record: current,

package/dist/automatic-service-capture.js

@@ -0,0 +1,27 @@
+import { captureExactService } from "./computer-service.js";
+import { ManagedServiceConflictError, ManagedServiceRegistryError, managedServiceConflict, managedServiceIdentityMatches, readManagedServiceRegistry, } from "./managed-service-registry.js";
+/** Read-only preflight; keep the record needed to restore the captured service. */
+export async function captureManagedServiceForSetup(input) {
+    const managedRecords = await readManagedServiceRegistry(input.registry);
+    const { generation: _generation, createdAt: _createdAt, ...expected } = input.record;
+    const registered = managedRecords.find((record) => managedServiceIdentityMatches(record, {
+        ...expected, descriptorSha256: record.descriptorSha256,
+    }));
+    if (registered === undefined) {
+        const conflict = managedServiceConflict(managedRecords, input.record);
+        if (conflict !== null) {
+            throw new ManagedServiceConflictError(conflict.resource, input.record, conflict.owner);
+        }
+    }
+    const snapshot = await captureExactService(input.spec, input.runner);
+    if (registered !== undefined && registered.descriptorSha256 !== expected.descriptorSha256
+        && (!snapshot.installed || !snapshot.exact)) {
+        throw new ManagedServiceRegistryError(`Installed descriptor for '${input.spec.id}' does not match the requested identity`);
+    }
+    // A stale hash may be reconciled later under the registry lock. Rollback must
+    // refer to the descriptor we actually captured, not the stale registry hash.
+    const previousManagedRecord = registered === undefined ? undefined : {
+        ...registered, descriptorSha256: expected.descriptorSha256,
+    };
+    return { managedRecords, previousManagedRecord, snapshot };
+}

package/dist/execution-telemetry-journal.js

@@ -1,8 +1,9 @@
-import { access, open, mkdir, readdir, readFile, rename, unlink } from "node:fs/promises";
+import { access, open, mkdir, readdir, readFile, rename, unlink, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { DaemonToServerExecutionFrameSchema, } from "./execution-protocol.js";
 const MAX_PENDING_FILES = 4_096;
+const MAX_TELEMETRY_FRAME_BYTES = 256 * 1_024;
 const fileName = (frame) => `${frame.executionId}.${frame.type === "execution:activity" ? "activity" : "console"}.${frame.seq}.json`;
 export class ExecutionTelemetryJournal {
     directory;
@@ -10,6 +11,10 @@ export class ExecutionTelemetryJournal {
         this.directory = join(agentsRoot, ".execution-telemetry");
     }
     async append(frame) {
+        const serialized = JSON.stringify(frame);
+        if (Buffer.byteLength(serialized) > MAX_TELEMETRY_FRAME_BYTES) {
+            throw new Error("execution telemetry frame exceeds 256 KiB");
+        }
         await mkdir(this.directory, { recursive: true, mode: 0o700 });
         const path = join(this.directory, fileName(frame));
         if (await access(path).then(() => true, () => false))
@@ -22,7 +27,7 @@ export class ExecutionTelemetryJournal {
         let handle;
         try {
             handle = await open(tempPath, "wx", 0o600);
-            await handle.writeFile(JSON.stringify(frame), "utf8");
+            await handle.writeFile(serialized, "utf8");
             await handle.sync();
             await handle.close();
             handle = undefined;
@@ -43,29 +48,36 @@ export class ExecutionTelemetryJournal {
                 throw error;
         });
     }
-    async replay() {
+    async *replay(onInvalid) {
         const names = await readdir(this.directory).catch((error) => {
             if (error.code === "ENOENT")
                 return [];
             throw error;
         });
-        const frames = [];
-        for (const name of names.filter((entry) => entry.endsWith(".json")).sort()) {
+        for (const name of names.filter((entry) => entry.endsWith(".json")).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }))) {
             let raw;
             try {
-                raw = JSON.parse(await readFile(join(this.directory, name), "utf8"));
+                const path = join(this.directory, name);
+                if ((await stat(path)).size > MAX_TELEMETRY_FRAME_BYTES) {
+                    throw new Error("execution telemetry frame exceeds 256 KiB");
+                }
+                raw = JSON.parse(await readFile(path, "utf8"));
+                const parsed = DaemonToServerExecutionFrameSchema.safeParse(raw);
+                if (!parsed.success || (parsed.data.type !== "execution:activity" && parsed.data.type !== "execution:console")) {
+                    throw new Error("invalid execution telemetry frame");
+                }
+                yield parsed.data;
             }
             catch (error) {
-                throw new Error(`invalid execution telemetry journal entry: ${name}`, { cause: error });
-            }
-            const parsed = DaemonToServerExecutionFrameSchema.safeParse(raw);
-            if (!parsed.success || (parsed.data.type !== "execution:activity" && parsed.data.type !== "execution:console")) {
-                throw new Error(`invalid execution telemetry journal entry: ${name}`);
+                // ACK 可与目录扫描并发删除条目。
+                if (error.code === "ENOENT")
+                    continue;
+                const invalid = new Error(`invalid execution telemetry journal entry: ${name}`, { cause: error });
+                if (!onInvalid)
+                    throw invalid;
+                onInvalid(invalid);
             }
-            frames.push(parsed.data);
         }
-        return frames.sort((left, right) => left.at.localeCompare(right.at)
-            || left.type.localeCompare(right.type) || left.seq - right.seq);
     }
 }
 export const createExecutionTelemetryJournal = (agentsRoot) => new ExecutionTelemetryJournal(agentsRoot);

package/dist/execution-telemetry-sender.js

@@ -0,0 +1,151 @@
+import { dslog } from "./slog.js";
+import {} from "./execution-telemetry-journal.js";
+const MAX_IN_FLIGHT = 16;
+const MAX_IN_FLIGHT_BYTES = 512 * 1_024;
+const ACK_TIMEOUT_MS = 30_000;
+const keyOf = (executionId, kind, seq) => `${executionId}.${kind}.${seq}`;
+/** 复用 journal 与 event-ack。窗口只保留游标，帧内容按需从磁盘读取。 */
+export class ExecutionTelemetrySender {
+    journal;
+    onError;
+    inFlight = new Map();
+    generation = 0;
+    running = false;
+    requested = false;
+    windowBlocked = false;
+    lastProgress = 0;
+    lastReportAt = 0;
+    lastErrorAt = -Infinity;
+    sentFrames = 0;
+    acknowledgedFrames = 0;
+    send;
+    timer;
+    constructor(journal, onError) {
+        this.journal = journal;
+        this.onError = onError;
+    }
+    start(send, onTimeout) {
+        this.stop();
+        this.send = send;
+        this.sentFrames = 0;
+        this.acknowledgedFrames = 0;
+        this.lastReportAt = Date.now();
+        this.logState("execution.telemetry_connected", "遥测补传连接已建立");
+        this.timer = setInterval(() => {
+            // 单个失败帧不能打断仍在正常确认的连接；只有整个窗口停滞才重连。
+            if (this.windowBlocked && Date.now() - this.lastProgress >= ACK_TIMEOUT_MS) {
+                this.logState("execution.telemetry_stalled", "遥测确认窗口停滞，准备重连", {
+                    level: "WARN", stalled_ms: Date.now() - this.lastProgress,
+                });
+                this.stop();
+                onTimeout();
+            }
+            else if (this.inFlight.size > 0 && Date.now() - this.lastReportAt >= ACK_TIMEOUT_MS) {
+                this.lastReportAt = Date.now();
+                this.logState("execution.telemetry_progress", "遥测确认窗口状态");
+            }
+        }, 1_000);
+        this.timer.unref();
+        this.notify();
+    }
+    stop() {
+        if (this.send)
+            this.logState("execution.telemetry_disconnected", "遥测发送停止，未确认帧保留在 journal");
+        this.generation += 1;
+        this.send = undefined;
+        this.requested = false;
+        this.windowBlocked = false;
+        if (this.timer !== undefined)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        this.inFlight.clear();
+    }
+    async acknowledge(executionId, kind, seq) {
+        const key = keyOf(executionId, kind, seq);
+        const entry = this.inFlight.get(key);
+        if (!entry)
+            return;
+        await this.journal.acknowledge(executionId, kind, seq);
+        // 重连会清空窗口；条目身份也能挡住旧连接和重复 ACK 的异步完成。
+        if (this.inFlight.get(key) !== entry)
+            return;
+        this.inFlight.delete(key);
+        this.acknowledgedFrames += 1;
+        this.lastProgress = Date.now();
+        this.notify();
+    }
+    notify() {
+        if (!this.send)
+            return;
+        this.requested = true;
+        if (!this.running)
+            void this.pump();
+    }
+    get bytes() {
+        let bytes = 0;
+        for (const entry of this.inFlight.values())
+            bytes += entry.bytes;
+        return bytes;
+    }
+    logState(event, message, fields = {}) {
+        dslog(event, message, {
+            generation: this.generation, in_flight_frames: this.inFlight.size,
+            in_flight_bytes: this.bytes, sent_frames: this.sentFrames,
+            acknowledged_frames: this.acknowledgedFrames, window_blocked: this.windowBlocked, ...fields,
+        });
+    }
+    reportError(error) {
+        // 同一个坏文件会被多次扫描；不要让错误日志形成新的无界积压。
+        if (Date.now() - this.lastErrorAt < ACK_TIMEOUT_MS)
+            return;
+        this.lastErrorAt = Date.now();
+        this.onError(error);
+    }
+    async pump() {
+        this.running = true;
+        const generation = this.generation;
+        try {
+            while (this.send && generation === this.generation && this.requested) {
+                this.requested = false;
+                let blocked = false;
+                // 本轮读取中的文件可能刚收到 ACK；不能把已删除游标的旧读取结果再发出去。
+                const alreadySent = new Set(this.inFlight.keys());
+                for await (const frame of this.journal.replay((error) => this.reportError(error))) {
+                    if (!this.send || generation !== this.generation)
+                        return;
+                    const key = keyOf(frame.executionId, frame.type === "execution:activity" ? "activity" : "console", frame.seq);
+                    if (alreadySent.has(key) || this.inFlight.has(key))
+                        continue;
+                    const bytes = Buffer.byteLength(JSON.stringify(frame));
+                    if (this.inFlight.size >= MAX_IN_FLIGHT || this.bytes + bytes > MAX_IN_FLIGHT_BYTES) {
+                        blocked = true;
+                        break;
+                    }
+                    if (this.inFlight.size === 0)
+                        this.lastProgress = Date.now();
+                    this.inFlight.set(key, { bytes });
+                    if (!this.send(frame)) {
+                        this.inFlight.delete(key);
+                        this.logState("execution.telemetry_send_failed", "遥测发送失败，帧保留在 journal", { level: "WARN" });
+                        return;
+                    }
+                    this.sentFrames += 1;
+                }
+                if (!this.send || generation !== this.generation)
+                    return;
+                blocked ||= this.inFlight.size >= MAX_IN_FLIGHT || this.bytes >= MAX_IN_FLIGHT_BYTES;
+                if (blocked && !this.windowBlocked)
+                    this.lastProgress = Date.now();
+                this.windowBlocked = blocked;
+            }
+        }
+        catch (error) {
+            this.reportError(error);
+        }
+        finally {
+            this.running = false;
+            if (this.send && this.requested)
+                this.notify();
+        }
+    }
+}

package/dist/managed-service-lifecycle.js

@@ -103,6 +103,16 @@ export async function installManagedService(input) {
             && record.daemonHome === input.record.daemonHome);
         if (registered !== undefined && sameManagedResource(registered, input.record)) {
             const current = await readServiceDescriptor(input.spec);
+            // Descriptor replacement and registry commit can be interrupted separately.
+            // Adopt only the exact requested descriptor with all resource fields intact.
+            if (current === requestedDescriptor) {
+                assertRecordDescribesSpec(input);
+                await ensureServiceEnabled(input.spec, input.runner);
+                await replace(services.map((record) => record === registered
+                    ? { ...record, descriptorSha256: expectedDescriptorHash }
+                    : record));
+                return;
+            }
             if (current === null || serviceDescriptorSha256(current) !== registered.descriptorSha256) {
                 throw new ManagedServiceRegistryError(`Installed descriptor for '${input.spec.id}' does not match its registry record`);
             }

package/dist/project-skills/execution-projection.js

@@ -85,11 +85,10 @@ export async function materializeExecutionProjection(input) {
                 continue;
             let projected;
             try {
-                // `projectDirectory`'s symlink path never lstats the source (POSIX symlink() happily
-                // creates a dangling link), so a source that vanished between scan and materialize would
-                // otherwise be silently projected as a broken link instead of failing loudly.
-                const sourceExists = await lstat(record.sourcePath).then(() => true, () => false);
-                if (!sourceExists)
+                // 源路径已由 reconciler 解析;拒绝解析后消失、变成文件或被替换为链接的目录。
+                // POSIX symlink() 本身允许断链,不能用“创建链接成功”代替源目录检查。
+                const source = await lstat(record.sourcePath).catch(() => null);
+                if (!source?.isDirectory() || source.isSymbolicLink())
                     throw new ExecutionProjectionError("link_failed");
                 projected = await project(record.sourcePath, join(root.codexSkillRoot, record.skillName), platform);
             }

package/dist/project-skills/reconciler.js

@@ -1,13 +1,14 @@
 /**
  * Project Skill 解析 + 执行编排。
- * reconcile: server 同步绑定时只解析"哪些 skill 在本机可用",不碰磁盘。
+ * reconcile: server 同步绑定时只读取"哪些 skill 在本机可用",不写入投影。
  * prepareAndLaunch: 为这一次 execution 建独占投影目录 → 启动 runtime → 进程树确认退出后删除。
  * 没有共享目录,所以没有锁、租约、manifest、GC。ownership 未确认时目录保留,交给启动 sweep。
  */
-import { lstat, stat } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 import { join, resolve, sep } from "node:path";
 import { ExecutionProjectionError, materializeExecutionProjection, removeExecutionProjection, } from "./execution-projection.js";
 import { projectSkillResolutionRecords } from "./scanner.js";
+import { resolveProjectSkillDirectory } from "./source-directory.js";
 import { compareProjectSkillRefs, } from "./types.js";
 export class ProjectProjectionError extends Error {
     code;
@@ -46,16 +47,14 @@ const canonicalConflictFreeBindings = (bindings) => {
     }
     return Object.freeze(unique);
 };
-/** 源目录必须是真实目录且有 SKILL.md,否则按 missing 处理(warning,不阻断)。 */
+/** 每次从扫描入口解析真实目录,固定本次执行的链接目标;不可用则 warning,不阻断。 */
 const actualResolutionRecords = async (bindings, projects, platform) => Object.freeze(await Promise.all(projectSkillResolutionRecords(bindings, projects, platform).map(async (record) => {
     if (record.mode === "missing" || record.sourcePath === null)
         return record;
-    const [source, skillFile] = await Promise.all([
-        lstat(record.sourcePath).catch(() => null),
-        stat(join(record.sourcePath, "SKILL.md")).catch(() => null),
-    ]);
-    if (source?.isDirectory() === true && !source.isSymbolicLink() && skillFile?.isFile() === true) {
-        return record;
+    const directory = await resolveProjectSkillDirectory(record.sourcePath);
+    const skillFile = directory === null ? null : await stat(join(directory, "SKILL.md")).catch(() => null);
+    if (directory !== null && skillFile?.isFile() === true) {
+        return Object.freeze({ ...record, sourcePath: directory });
     }
     return Object.freeze({
         projectId: record.projectId,

package/dist/project-skills/scanner.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { compareProjectSkillRefs, isProjectSkillName, MAX_MACHINE_PROJECT_SKILLS, MAX_PROJECT_SKILL_DESCRIPTION_LENGTH, MAX_PROJECT_SKILL_FILE_BYTES, MAX_PROJECT_SKILLS_PER_PROJECT, } from "./types.js";
 import { parseSkillFrontmatter } from "../skill-frontmatter.js";
 import { normalizeProjectSkillResolutionRecords } from "./resolution-records.js";
+import { resolveProjectSkillDirectory } from "./source-directory.js";
 const unavailable = (projectId, scannedAt, errorCode) => Object.freeze({
     inventory: Object.freeze({
         projectId,
@@ -45,10 +46,15 @@ export async function scanProject(project, now = () => new Date()) {
     let invalidSkillCount = 0;
     const candidates = [];
     for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-        if (entry.name.startsWith(".") || !entry.isDirectory())
+        if (entry.name.startsWith(".") || (!entry.isDirectory() && !entry.isSymbolicLink()))
             continue;
         const sourcePath = join(skillsRoot, entry.name);
-        const skillPath = join(sourcePath, "SKILL.md");
+        const directory = await resolveProjectSkillDirectory(sourcePath);
+        if (directory === null) {
+            invalidSkillCount += 1;
+            continue;
+        }
+        const skillPath = join(directory, "SKILL.md");
         const skillStat = await stat(skillPath).catch(() => null);
         if (!skillStat?.isFile() || skillStat.size > MAX_PROJECT_SKILL_FILE_BYTES) {
             invalidSkillCount += 1;
@@ -70,6 +76,7 @@ export async function scanProject(project, now = () => new Date()) {
             invalidSkillCount += 1;
             continue;
         }
+        // 保留入口:执行前重新解析,才能识别链接删除或改指。
         candidates.push(Object.freeze({ name, description, sourcePath }));
     }
     const counts = new Map();

package/dist/project-skills/source-directory.js

@@ -0,0 +1,13 @@
+import { lstat, realpath } from "node:fs/promises";
+/** 跟随用户放置的源链接;只在本次操作中使用真实目录,不把它缓存为扫描入口。 */
+export async function resolveProjectSkillDirectory(sourcePath) {
+    try {
+        const directory = await realpath(sourcePath);
+        const info = await lstat(directory);
+        return info.isDirectory() && !info.isSymbolicLink() ? directory : null;
+    }
+    catch {
+        // 断链、循环或权限不足只使这个 Skill 不可用,不影响其它 Skill。
+        return null;
+    }
+}

package/dist/serve.js

@@ -1,3 +1,4 @@
+import { ExecutionTelemetrySender } from "./execution-telemetry-sender.js";
 /** 常驻控制面桥接；按请求拉起本地 runtime。 */
 import { handleAgentEnvironmentFrame } from "./agent-environment-control.js";
 import { handleMachineEnvironmentFrame } from "./machine-environment-control.js";
@@ -80,6 +81,11 @@ export function serve(config, opts = {}) {
     const agentMemory = opts.execution?.dependencies?.agentMemory
         ?? (config.agentMemory === null ? undefined : createAgentMemoryBridge(config.agentMemory));
     const executionTelemetry = createExecutionTelemetryJournal(config.agentsRoot);
+    const telemetrySender = new ExecutionTelemetrySender(executionTelemetry, (error) => {
+        dslog("execution.telemetry_replay_failed", "execution telemetry 重放失败", {
+            level: "ERROR", error_message: error.message,
+        });
+    });
     const executeProtocol = opts.execution?.runExecution ?? runExecution;
     const localHome = opts.localHome ?? resolveDaemonLocalStateRootFromEnv();
     const hostCoordinator = opts.execution?.hostCoordinator
@@ -234,6 +240,8 @@ export function serve(config, opts = {}) {
         if (frame.type === "execution:activity" || frame.type === "execution:console") {
             try {
                 await executionTelemetry.append(frame);
+                telemetrySender.notify();
+                return;
             }
             catch (error) {
                 dslog("execution.telemetry_journal_failed", "execution telemetry 持久化失败", {
@@ -254,11 +262,6 @@ export function serve(config, opts = {}) {
                 completionRetransmitter.track(entry.completion);
         }
     };
-    const replayExecutionTelemetry = async () => {
-        const frames = await executionTelemetry.replay();
-        for (const frame of frames)
-            safeExecutionSend(frame);
-    };
     const snapshotEntry = (entry) => {
         if ((entry.state === "completed" || entry.state === "interrupted") && entry.completion !== null) {
             return { executionId: entry.executionId, state: entry.state, completion: entry.completion, updatedAt: entry.updatedAt };
@@ -374,11 +377,7 @@ export function serve(config, opts = {}) {
                     completionRetransmitter.resume();
                 }
             });
-            void replayExecutionTelemetry().catch((error) => {
-                dslog("execution.telemetry_replay_failed", "execution telemetry 重放失败", {
-                    level: "ERROR", error_message: error.message,
-                });
-            });
+            telemetrySender.start((frame) => ws === openedSocket && safeExecutionSend(frame), () => openedSocket.close(1013, "telemetry ACK timeout"));
         });
         connectionSocket.on("message", async (data) => {
             if (stopped || ws !== connectionSocket)
@@ -450,7 +449,7 @@ export function serve(config, opts = {}) {
                         return;
                     }
                     if (frame.type === "execution:event-ack") {
-                        await executionTelemetry.acknowledge(frame.executionId, frame.kind, frame.seq).catch((error) => {
+                        await telemetrySender.acknowledge(frame.executionId, frame.kind, frame.seq).catch((error) => {
                             dslog("execution.telemetry_ack_failed", "execution telemetry ACK 处理失败", {
                                 level: "ERROR", execution_id: frame.executionId,
                                 error_message: error.message,
@@ -1263,6 +1262,7 @@ export function serve(config, opts = {}) {
             // server 能力随连接失效;下个连接的 ready 帧重新声明(防降级重连后沿用过期能力)。
             serverCapabilities = new Set();
             completionRetransmitter.pause();
+            telemetrySender.stop();
             // 4001 = 控制面应用级「鉴权失败」关闭码(见 server control-plane.ts)。即使上面的
             // error 帧因 close 抢先而丢失,也能据关闭码识别这是凭证失效——退避拉满,不再每秒热循环。
             if (reportDaemonConnectionClose(code, log))
@@ -1323,6 +1323,7 @@ export function serve(config, opts = {}) {
             stopped = true;
             concurrencyTelemetry.stop();
             completionRetransmitter.stop();
+            telemetrySender.stop();
             const deadline = createShutdownDeadline(shutdownTimeoutMs);
             if (reconnectTimer !== null) {
                 clearTimeout(reconnectTimer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.102-beta.3",
+  "version": "0.6.102-beta.5",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -18,17 +18,9 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
-    "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "pnpm build && node ../scripts/daemon-release-artifact.mjs --strict-registry",
-    "test": "vitest run",
-    "test:release-critical": "vitest run test/automatic-daemon-installer.test.ts test/automatic-install-target.test.ts test/automatic-service-migration.test.ts test/computer-cli.test.ts test/computer-service.test.ts test/computer-setup-client.test.ts test/computer-setup-orchestration.test.ts test/computer-setup.test.ts test/daemon-release-version.test.ts test/daemon-update-controller.test.ts test/daemon-update-eligibility.test.ts test/daemon-updater.test.ts test/execution-protocol.test.ts test/machine-info.test.ts --maxWorkers=2 --minWorkers=1",
-    "typecheck": "tsc --noEmit"
-  },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
-    "@nowcrew/cli": "0.4.17",
+    "@nowcrew/cli": "0.4.19-beta.1",
     "cross-spawn": "^7.0.6",
     "semver": "7.8.5",
     "smol-toml": "1.8.0",
@@ -47,5 +39,12 @@
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:release-critical": "vitest run test/automatic-daemon-installer.test.ts test/automatic-install-target.test.ts test/automatic-service-migration.test.ts test/computer-cli.test.ts test/computer-service.test.ts test/computer-setup-client.test.ts test/computer-setup-orchestration.test.ts test/computer-setup.test.ts test/daemon-release-version.test.ts test/daemon-update-controller.test.ts test/daemon-update-eligibility.test.ts test/daemon-updater.test.ts test/execution-protocol.test.ts test/machine-info.test.ts --maxWorkers=2 --minWorkers=1",
+    "typecheck": "tsc --noEmit"
   }
-}
+}