@nowcrew/daemon 0.6.19 → 0.6.21

package/dist/project-skills/controller.js

@@ -5,6 +5,7 @@ import { isProjectId, isProjectSkillName, compareProjectSkillRefs, MAX_AGENT_PRO
 import { ProjectProjectionError, } from "./reconciler.js";
 import { AgentHandleSchema } from "../execution-protocol.js";
 import { createPromiseTail } from "../promise-tail.js";
+import { createProjectSkillSnapshotEpoch, MAX_REMEMBERED_PROJECT_SKILL_AGENTS, toPathPrivateConvergenceResults, } from "./controller-convergence.js";
 const ProjectIdSchema = z.string().refine(isProjectId);
 const AgentSkillsSyncSchema = z.object({
     type: z.literal("agent:skills:sync"),
@@ -56,6 +57,13 @@ class ProjectScanTimeoutError extends Error {
         this.name = "ProjectScanTimeoutError";
     }
 }
+class ProjectSkillStaleEpochError extends Error {
+    code = "skill_projection_stale";
+    constructor() {
+        super("skill_projection_stale");
+        this.name = "ProjectSkillStaleEpochError";
+    }
+}
 const withinScanDeadline = async (operation, timeoutMs) => {
     let timer;
     try {
@@ -79,7 +87,12 @@ export function createProjectSkillsController(deps) {
     let initializationState = "idle";
     const scan = deps.scan ?? scanProjects;
     const scanTimeoutMs = deps.scanTimeoutMs ?? DEFAULT_PROJECT_SCAN_TIMEOUT_MS;
-    const v2Snapshots = new Map();
+    const snapshotEpoch = createProjectSkillSnapshotEpoch();
+    let connectionEpochIdentity = Object.freeze({});
+    const assertCurrentEpoch = (token) => {
+        if (token !== undefined && token !== connectionEpochIdentity)
+            throw new ProjectSkillStaleEpochError();
+    };
     const scanCurrent = async (deferredProjectId) => withinScanDeadline(scan(await deps.registry.list(), undefined, [
         ...scanned
             .map((project) => project.inventory.projectId)
@@ -97,17 +110,25 @@ export function createProjectSkillsController(deps) {
         }));
     };
     const enqueue = (operation) => operationTail.enqueue(operation);
-    const applyV2Snapshot = async (handle, snapshot) => {
+    const applyV2Snapshot = async (handle, snapshot, epochToken) => {
         if (deps.ensureSnapshot === undefined)
             throw new ProjectProjectionError("skill_projection_failed");
-        await deps.ensureSnapshot(handle, snapshot);
-        const previous = v2Snapshots.get(handle);
-        if (previous === undefined || snapshot.generation >= previous.generation) {
-            v2Snapshots.set(handle, Object.freeze({
-                bindings: Object.freeze(snapshot.bindings.map((binding) => Object.freeze({ ...binding }))),
-                generation: snapshot.generation,
-            }));
+        assertCurrentEpoch(epochToken);
+        const acceptedEpochIdentity = connectionEpochIdentity;
+        const rememberedEntries = snapshotEpoch.entries();
+        const firstAcceptedInEpoch = !rememberedEntries.some(([candidate]) => candidate === handle);
+        if (firstAcceptedInEpoch && rememberedEntries.length >= MAX_REMEMBERED_PROJECT_SKILL_AGENTS) {
+            throw new ProjectProjectionError("skill_projection_failed");
+        }
+        if (firstAcceptedInEpoch) {
+            await deps.ensureSnapshot(handle, snapshot, Object.freeze({ refreshCopyProjection: true }));
+        }
+        else {
+            await deps.ensureSnapshot(handle, snapshot);
         }
+        assertCurrentEpoch(epochToken);
+        if (acceptedEpochIdentity === connectionEpochIdentity)
+            snapshotEpoch.remember(handle, snapshot);
         return Object.freeze(projectSkillResolutionRecords(snapshot.bindings, scanned)
             .map((record) => Object.freeze({
             projectId: record.projectId,
@@ -115,15 +136,24 @@ export function createProjectSkillsController(deps) {
             status: record.mode === "resolved" ? "linked" : "unavailable",
         })));
     };
-    const reapplyV2Snapshots = async () => {
-        if (deps.ensureSnapshot === undefined) {
-            if (v2Snapshots.size > 0)
-                throw new ProjectProjectionError("skill_projection_failed");
+    const convergeV2Snapshots = async (refreshCopyProjection, epochToken) => {
+        assertCurrentEpoch(epochToken);
+        const acceptedEpochIdentity = connectionEpochIdentity;
+        const entries = snapshotEpoch.entries();
+        if (deps.ensureSnapshot === undefined || entries.length === 0)
+            return;
+        const results = await Promise.allSettled(entries.map(([handle, snapshot]) => refreshCopyProjection
+            ? deps.ensureSnapshot(handle, snapshot, Object.freeze({ refreshCopyProjection: true }))
+            : deps.ensureSnapshot(handle, snapshot)));
+        if (acceptedEpochIdentity !== connectionEpochIdentity) {
+            if (epochToken !== undefined)
+                throw new ProjectSkillStaleEpochError();
             return;
         }
-        for (const [handle, snapshot] of [...v2Snapshots.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)) {
-            await deps.ensureSnapshot(handle, snapshot);
+        try {
+            deps.onConvergence?.(toPathPrivateConvergenceResults(entries, results));
         }
+        catch { /* convergence diagnostics must not change a successful inventory mutation */ }
     };
     const initialize = () => {
         if (initializationState === "ready" && initialization !== null)
@@ -141,24 +171,40 @@ export function createProjectSkillsController(deps) {
         return attempt;
     };
     return {
+        beginConnectionEpoch: () => {
+            connectionEpochIdentity = Object.freeze({});
+            snapshotEpoch.begin();
+            return connectionEpochIdentity;
+        },
         initialize,
         publishCurrent: () => enqueue(publishCurrent),
         scannedProjects: () => scanned,
-        async handle(input) {
+        async handle(input, epochToken) {
             const parsed = ProjectCommandSchema.safeParse(input);
             if (!parsed.success)
                 return { ok: false, error: "invalid_project_command" };
+            try {
+                assertCurrentEpoch(epochToken);
+            }
+            catch (error) {
+                return { ok: false, error: error.code };
+            }
             if (parsed.data.type === "agent:skills:sync") {
                 try {
                     await initialize();
+                    assertCurrentEpoch(epochToken);
                 }
                 catch {
+                    if (epochToken !== undefined && epochToken !== connectionEpochIdentity) {
+                        return { ok: false, error: "skill_projection_stale" };
+                    }
                     return { ok: false, error: "project_skills_unavailable" };
                 }
             }
             return enqueue(async () => {
                 const command = parsed.data;
                 try {
+                    assertCurrentEpoch(epochToken);
                     if (command.type === "agent:skills:sync") {
                         if (command.generation !== undefined) {
                             const snapshot = Object.freeze({
@@ -167,13 +213,14 @@ export function createProjectSkillsController(deps) {
                             });
                             return {
                                 ok: true,
-                                data: { bindings: await applyV2Snapshot(command.handle, snapshot) },
+                                data: { bindings: await applyV2Snapshot(command.handle, snapshot, epochToken) },
                             };
                         }
                         if (deps.reconcile === undefined)
                             return { ok: false, error: "skill_projection_failed" };
                         const bindings = await deps.reconcile(command.handle, command.bindings);
-                        v2Snapshots.delete(command.handle);
+                        assertCurrentEpoch(epochToken);
+                        snapshotEpoch.forget(command.handle);
                         return {
                             ok: true,
                             data: { bindings },
@@ -182,8 +229,11 @@ export function createProjectSkillsController(deps) {
                     if (command.type === "project:add") {
                         const existed = (await deps.registry.list())
                             .some((project) => project.projectId === command.projectId);
+                        assertCurrentEpoch(epochToken);
                         await deps.registry.add(command.projectId, command.root);
+                        assertCurrentEpoch(epochToken);
                         const next = await scanCurrent();
+                        assertCurrentEpoch(epochToken);
                         const added = next.find((project) => project.inventory.projectId === command.projectId);
                         if (!existed && added?.inventory.errorCode === "machine_project_skill_limit_exceeded") {
                             await deps.registry.remove(command.projectId);
@@ -193,9 +243,11 @@ export function createProjectSkillsController(deps) {
                     }
                     else if (command.type === "project:remove") {
                         await deps.registry.remove(command.projectId);
+                        assertCurrentEpoch(epochToken);
                     }
                     else {
                         const projects = await deps.registry.list();
+                        assertCurrentEpoch(epochToken);
                         if (!projects.some((project) => project.projectId === command.projectId)) {
                             return { ok: false, error: "project_not_found" };
                         }
@@ -203,8 +255,10 @@ export function createProjectSkillsController(deps) {
                     if (command.type !== "project:add") {
                         await refresh(command.type === "project:rescan" ? command.projectId : undefined);
                     }
-                    await reapplyV2Snapshots();
+                    assertCurrentEpoch(epochToken);
                     await publishCurrent();
+                    assertCurrentEpoch(epochToken);
+                    await convergeV2Snapshots(command.type === "project:rescan", epochToken);
                     return { ok: true, data: { projectId: command.projectId } };
                 }
                 catch (error) {
@@ -214,11 +268,13 @@ export function createProjectSkillsController(deps) {
                             ? error.code
                             : error.code === "skill_name_conflict"
                                 ? "skill_name_conflict"
-                                : error.code === "skill_projection_failed"
-                                    ? "skill_projection_failed"
-                                    : error.code === "skill_projection_snapshot_corrupt"
-                                        ? "skill_projection_snapshot_corrupt"
-                                        : "project_operation_failed",
+                                : error.code === "skill_projection_stale"
+                                    ? "skill_projection_stale"
+                                    : error.code === "skill_projection_failed"
+                                        ? "skill_projection_failed"
+                                        : error.code === "skill_projection_snapshot_corrupt"
+                                            ? "skill_projection_snapshot_corrupt"
+                                            : "project_operation_failed",
                     };
                 }
             });

package/dist/project-skills/initialized-reconciler.js

@@ -10,11 +10,11 @@ export function initializedProjectSkillsReconciler(ensureInitialized, reconciler
         async reconcile(handle, bindings) {
             return (await ready()).reconcile(handle, bindings);
         },
-        async ensureSnapshot(handle, snapshot) {
-            return (await ready()).ensureSnapshot(handle, snapshot);
+        async ensureSnapshot(handle, snapshot, options) {
+            return (await ready()).ensureSnapshot(handle, snapshot, options);
         },
-        async prepareAndLaunch(agentsRoot, handle, projection, launch, onWarning) {
-            return (await ready()).prepareAndLaunch(agentsRoot, handle, projection, launch, onWarning);
+        async prepareAndLaunch(agentsRoot, executionId, handle, projection, launch, onWarning) {
+            return (await ready()).prepareAndLaunch(agentsRoot, executionId, handle, projection, launch, onWarning);
         },
     };
 }

package/dist/project-skills/projection-state-domain.js

@@ -6,6 +6,7 @@ const MANAGED_BY = "nowcrew-project-skills-v2";
 const MAX_SOURCE_PATH_BYTES = 16 * 1024;
 const MAX_GENERATION = 2_147_483_647;
 const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const CANONICAL_ROOT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 export class ProjectSkillProjectionStateError extends Error {
     code;
     constructor(code) {
@@ -106,7 +107,8 @@ export function createAppliedProjectSkillManifest(input) {
     const bindings = canonicalBindings(input.bindings);
     const resolutions = normalizeProjectSkillResolutionRecords(input.resolutions, input.platform);
     if (bindings.length !== resolutions.length
-        || bindings.some((binding, index) => !sameBinding(binding, resolutions[index]))) {
+        || bindings.some((binding, index) => !sameBinding(binding, resolutions[index]))
+        || !CANONICAL_ROOT_ID.test(input.rootId)) {
         return corrupt();
     }
     return Object.freeze({
@@ -115,19 +117,26 @@ export function createAppliedProjectSkillManifest(input) {
         bindings,
         bindingDigest: digest(bindings),
         resolutionDigest: digest(resolutions),
+        rootId: input.rootId,
     });
 }
 const ProjectSkillRefSchema = z.object({
     projectId: z.string().min(1).max(MAX_PROJECT_ID_LENGTH),
     skillName: z.string().min(1).max(MAX_PROJECT_SKILL_NAME_LENGTH),
 }).strict();
-const AppliedManifestSchema = z.object({
+const LegacyAppliedManifestSchema = z.object({
     managedBy: z.literal(MANAGED_BY),
     generation: z.number().int().min(0).max(MAX_GENERATION),
     bindings: z.array(ProjectSkillRefSchema).max(MAX_AGENT_PROJECT_SKILL_BINDINGS),
     bindingDigest: z.string().regex(DIGEST),
     resolutionDigest: z.string().regex(DIGEST),
 }).strict();
+const AppliedManifestSchema = z.union([
+    LegacyAppliedManifestSchema.extend({
+        rootId: z.string().regex(CANONICAL_ROOT_ID),
+    }).strict(),
+    LegacyAppliedManifestSchema,
+]);
 /** Strict local-store boundary parser; not re-exported from the public projection-state facade. */
 export const parseAppliedProjectSkillManifest = (candidate) => {
     if (candidate && typeof candidate === "object" && "managedBy" in candidate
@@ -149,5 +158,13 @@ export const parseAppliedProjectSkillManifest = (candidate) => {
         bindings,
         bindingDigest: parsed.data.bindingDigest,
         resolutionDigest: parsed.data.resolutionDigest,
+        rootId: "rootId" in parsed.data ? parsed.data.rootId : null,
     });
 };
+/** Publication boundary parser; it must run before creating or settling any filesystem state. */
+export const parsePublishableAppliedProjectSkillManifest = (candidate) => {
+    const parsed = parseAppliedProjectSkillManifest(candidate);
+    if (parsed.rootId === null)
+        return corrupt();
+    return Object.freeze({ ...parsed, rootId: parsed.rootId });
+};

package/dist/project-skills/projection-state-store.js

@@ -3,7 +3,7 @@ import { chmod, link, lstat, mkdir, open, opendir, rename, rmdir, unlink } from
 import { basename, dirname, join } from "node:path";
 import { z } from "zod";
 import { durableDirectorySync } from "../atomic-private-write.js";
-import { parseAppliedProjectSkillManifest, ProjectSkillProjectionStateError, } from "./projection-state-domain.js";
+import { parseAppliedProjectSkillManifest, parsePublishableAppliedProjectSkillManifest, ProjectSkillProjectionStateError, } from "./projection-state-domain.js";
 const MANIFEST_FILE_NAME = "project-skills-v2.json";
 const MAX_MANIFEST_BYTES = 256 * 1024;
 const MAX_CONSISTENT_READ_ATTEMPTS = 6;
@@ -665,7 +665,7 @@ export async function readAppliedProjectSkillManifest(agentRoot, options = {}) {
         : parseManifestRaw(snapshot.raw);
 }
 export async function writeAppliedProjectSkillManifest(agentRoot, manifest, options = {}) {
-    const parsed = parseAppliedProjectSkillManifest(manifest);
+    const parsed = parsePublishableAppliedProjectSkillManifest(manifest);
     const syncDirectory = projectionDirectorySync(options);
     await realOwnedDirectory(agentRoot, false);
     const stateDirectory = join(agentRoot, ".crew");
@@ -827,6 +827,7 @@ export const projectSkillManifestStoreInternals = Object.freeze({
     isAbsenceMarkerRaw,
     loadOperation,
     parseAppliedProjectSkillManifest,
+    parsePublishableAppliedProjectSkillManifest,
     parseManifestRaw,
     pathUnmanaged,
     projectionDirectorySync,

package/dist/project-skills/projection-state-transaction.js

@@ -190,11 +190,15 @@ const prepareManifestTransition = async (agentRoot, next, options = {}) => {
     return Object.freeze({ agentRoot, operationId: operation.intent.nonce, previous, next });
 };
 export async function prepareAppliedProjectSkillManifestUpdate(agentRoot, manifest, options = {}) {
-    return prepareManifestTransition(agentRoot, store.parseAppliedProjectSkillManifest(manifest), options);
+    return prepareManifestTransition(agentRoot, store.parsePublishableAppliedProjectSkillManifest(manifest), options);
 }
 export async function prepareAppliedProjectSkillManifestRemoval(agentRoot, options = {}) {
     return prepareManifestTransition(agentRoot, null, options);
 }
+/** Settles a durable standalone applied-manifest operation before current-state selection. */
+export async function recoverAppliedProjectSkillManifestUpdates(agentRoot, options = {}) {
+    await stateContext(agentRoot, options, true);
+}
 export async function publishPreparedProjectSkillManifestUpdate(update, options = {}) {
     if (await completedWithoutOperation(update, update.next, options))
         return;

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

@@ -1,3 +1,3 @@
 export { computeProjectSkillBindingDigest, computeProjectSkillResolutionDigest, createAppliedProjectSkillManifest, normalizeProjectSkillResolutionRecords, ProjectSkillProjectionStateError, } from "./projection-state-domain.js";
 export { appliedProjectSkillManifestPath, readAppliedProjectSkillManifest, writeAppliedProjectSkillManifest, } from "./projection-state-store.js";
-export { commitPreparedProjectSkillManifestUpdate, parseProjectSkillManifestUpdateRecord, prepareAppliedProjectSkillManifestRemoval, prepareAppliedProjectSkillManifestUpdate, preparedProjectSkillManifestUpdateFromRecord, projectSkillManifestUpdateRecord, publishPreparedProjectSkillManifestUpdate, rollbackPreparedProjectSkillManifestUpdate, } from "./projection-state-transaction.js";
+export { commitPreparedProjectSkillManifestUpdate, parseProjectSkillManifestUpdateRecord, prepareAppliedProjectSkillManifestRemoval, prepareAppliedProjectSkillManifestUpdate, preparedProjectSkillManifestUpdateFromRecord, projectSkillManifestUpdateRecord, publishPreparedProjectSkillManifestUpdate, recoverAppliedProjectSkillManifestUpdates, rollbackPreparedProjectSkillManifestUpdate, } from "./projection-state-transaction.js";