@ikon85/agent-workflow-kit 0.30.0 → 0.31.0

package/src/lib/updateCandidate.mjs

@@ -6,7 +6,13 @@ import { promisify } from 'node:util';
 import { writeAtomic } from './atomicWrite.mjs';
 import { validateConsumerFile } from './consumerPath.mjs';
 import { sha256File } from './hash.mjs';
-import { CONSUMER_MANIFEST_NAME, indexByPath, readManifest } from './manifest.mjs';
+import { stubSentinel } from './sentinel.mjs';
+import { STUB_TARGETS } from './bundle.mjs';
+import {
+  CONSUMER_MANIFEST_NAME, CONSUMER_ORIGIN, READINESS_MANIFEST_PATH,
+  indexByPath, readManifest, writeManifest,
+} from './manifest.mjs';
+import { checkSkill, evaluateCapability } from '../../scripts/readiness.mjs';
 
 const run = promisify(execFile);
 const exists = (path) => access(path).then(() => true, () => false);
@@ -30,9 +36,11 @@ export async function stageConsumer(consumerRoot) {
 /** Activate only verified kit-owned deltas, rolling every touched path back on failure. */
 export async function activateCandidate({
   candidateRoot, consumerRoot, pkg, preview, consumerManifestBefore,
+  afterGenerated = async () => {},
 }) {
   const changed = [...preview.added, ...preview.updated];
-  const touched = [...changed, ...preview.deleted, CONSUMER_MANIFEST_NAME];
+  const generated = preview.generated ?? [];
+  const touched = [...changed, ...generated, ...preview.deleted, CONSUMER_MANIFEST_NAME];
   const currentManifest = await readFile(join(consumerRoot, CONSUMER_MANIFEST_NAME));
   if (!currentManifest.equals(consumerManifestBefore)) {
     throw new Error('consumer manifest changed during verification');
@@ -43,6 +51,13 @@ export async function activateCandidate({
       throw new Error(`candidate hash mismatch: ${path}`);
     }
   }
+  const candidateManifest = await readManifest(join(candidateRoot, CONSUMER_MANIFEST_NAME));
+  const candidateInstalled = indexByPath(candidateManifest, 'installed');
+  for (const path of generated) {
+    if (await sha256File(join(candidateRoot, path)) !== candidateInstalled.get(path)?.installedSha256) {
+      throw new Error(`generated candidate hash mismatch: ${path}`);
+    }
+  }
   await assertConsumerStillMatchesPreview(consumerRoot, preview);
   const rollback = new Map();
   for (const path of touched) rollback.set(path, await snapshot(join(consumerRoot, path)));
@@ -50,6 +65,10 @@ export async function activateCandidate({
     for (const path of changed) {
       await writeAtomic(join(consumerRoot, path), await readFile(join(candidateRoot, path)), pkgIdx.get(path)?.mode);
     }
+    for (const path of generated) {
+      await writeAtomic(join(consumerRoot, path), await readFile(join(candidateRoot, path)));
+    }
+    await afterGenerated();
     for (const path of preview.deleted) await rm(join(consumerRoot, path), { force: true });
     await writeAtomic(
       join(consumerRoot, CONSUMER_MANIFEST_NAME),
@@ -57,6 +76,7 @@ export async function activateCandidate({
     );
   } catch (error) {
     for (const path of touched.reverse()) await restore(join(consumerRoot, path), rollback.get(path));
+    error.consumerState = 'rolled-back';
     throw error;
   }
 }
@@ -80,6 +100,11 @@ async function assertConsumerStillMatchesPreview(consumerRoot, preview) {
     if (replacements.has(path)) continue;
     if (await exists(join(consumerRoot, path))) throw new Error(`consumer changed during verification: ${path}`);
   }
+  for (const path of preview.generated ?? []) {
+    if (await exists(join(consumerRoot, path))) {
+      throw new Error(`consumer changed during verification: ${path}`);
+    }
+  }
   for (const path of [...preview.updated, ...preview.deleted]) {
     const prior = installed.get(path);
     const current = await exists(join(consumerRoot, path))
@@ -90,6 +115,95 @@ async function assertConsumerStillMatchesPreview(consumerRoot, preview) {
   }
 }
 
+/** Seed only newly declared, decision-free project-layer stubs in a staged candidate. */
+export async function adoptReadinessCandidate({ candidateRoot, consumerRoot, priorManifest, nextManifest }) {
+  const priorPaths = readinessStubPaths(priorManifest);
+  const manifestPath = join(candidateRoot, CONSUMER_MANIFEST_NAME);
+  const manifest = await readManifest(manifestPath);
+  const candidateInstalled = indexByPath(manifest, 'installed');
+  const generated = [];
+  for (const path of readinessStubPaths(nextManifest)) {
+    if (priorPaths.has(path)) continue;
+    if (await exists(join(candidateRoot, path))) {
+      if (candidateInstalled.get(path)?.origin === CONSUMER_ORIGIN
+          && !await exists(join(consumerRoot, path))) generated.push(path);
+      continue;
+    }
+    if (await exists(join(consumerRoot, path))) continue;
+    await writeAtomic(join(candidateRoot, path), `${stubSentinel()}\n`);
+    generated.push(path);
+  }
+  if (generated.length) {
+    const installed = [...manifest.installed];
+    for (const generatedPath of generated) {
+      if (candidateInstalled.has(generatedPath)) continue;
+      installed.push({
+        path: generatedPath, kind: 'doc', installedSha256: await sha256File(join(candidateRoot, generatedPath)),
+        origin: CONSUMER_ORIGIN, installRole: 'consumer',
+      });
+    }
+    await writeManifest(manifestPath, { ...manifest, installed });
+  }
+  const before = await readinessSnapshot(consumerRoot, priorManifest);
+  const after = await readinessSnapshot(candidateRoot, nextManifest);
+  const incompatible = Object.entries(after.skills)
+    .filter(([skill, current]) => before.skills[skill]?.verdict !== 'blocked'
+      && before.skills[skill] && current.verdict === 'blocked')
+    .map(([skill]) => skill)
+    .sort();
+  return { generated, availability: readinessDiff(before, after), incompatible };
+}
+
+function readinessStubPaths(manifest) {
+  const safe = new Set(STUB_TARGETS);
+  return new Set(Object.values(manifest?.readiness?.capabilities ?? {}).flatMap((capability) => {
+    if (capability.evidence?.type !== 'sentinel') return [];
+    return (capability.evidence.paths ?? []).filter((path) => safe.has(path));
+  }));
+}
+
+async function readinessSnapshot(root, manifest) {
+  const skills = {};
+  for (const [name, declaration] of Object.entries(manifest?.skills ?? {})) {
+    if (!declaration.readiness) continue;
+    skills[name] = await checkSkill({ root, skill: name, manifest });
+  }
+  const consumer = await readManifest(join(root, CONSUMER_MANIFEST_NAME));
+  const capabilities = {};
+  for (const [name, capability] of Object.entries(manifest?.readiness?.capabilities ?? {})) {
+    capabilities[name] = await evaluateCapability({
+      root, capability, decision: consumer?.readinessDecisions?.[name],
+    });
+  }
+  return { skills, capabilities };
+}
+
+function readinessDiff(before, after) {
+  const newlyAvailable = [];
+  const newlyDegraded = [];
+  const newlyBlocked = [];
+  const unresolved = new Set();
+  for (const [skill, current] of Object.entries(after.skills)) {
+    const prior = before.skills[skill];
+    if (current.verdict === 'blocked' && prior?.verdict !== 'blocked') newlyBlocked.push(skill);
+    if (current.verdict !== 'blocked' && (!prior || prior.verdict === 'blocked')) newlyAvailable.push(skill);
+    for (const block of current.inactiveBlocks) {
+      if (!prior || !prior.inactiveBlocks.includes(block)) newlyDegraded.push(`${skill}.${block}`);
+    }
+  }
+  for (const [capability, result] of Object.entries(after.capabilities)) {
+    if (result.state !== 'ready') unresolved.add(`${capability}:${result.state}`);
+  }
+  return {
+    newlyAvailable: newlyAvailable.sort(), newlyDegraded: newlyDegraded.sort(),
+    newlyBlocked: newlyBlocked.sort(), stillUnresolved: [...unresolved].sort(),
+  };
+}
+
+export async function readReadinessManifest(root) {
+  return readManifest(join(root, READINESS_MANIFEST_PATH));
+}
+
 async function snapshot(path) {
   if (!await exists(path)) return null;
   const info = await stat(path);