@astrosheep/keiyaku 2.8.1 → 2.8.3

package/build/cli/help.js

@@ -14,6 +14,7 @@ export const CLI_COMMAND_METADATA = {
     revive: command("revive", "Revive an Akuma helper session", ["keiyaku revive ARTIFACT_ID"], "none", ["cwd", "repo", "model", "effort"], "Continue a persisted helper session."),
     wait: command("wait", "Wait for an akuma projection", ["keiyaku wait <projection-address> [--timeout DURATION]", "keiyaku @addr wait <projection-address> [--timeout DURATION]"], "none", ["cwd", "repo", "contract", "timeout"], "Read an akuma projection until its outcome is available, or show a timeout snapshot."),
     tell: command("tell", "Send intent to a projection mailbox", ["keiyaku tell [--effort LEVEL] PROJECTION MESSAGE", "keiyaku @addr tell [--effort LEVEL] PROJECTION MESSAGE"], "none", ["cwd", "repo", "contract", "effort"], "Write intent to the mailbox and wake only when eligible."),
+    kill: command("kill", "Stop the current projection generation", ["keiyaku kill <projection-address>", "keiyaku @addr kill <projection-address>"], "none", ["cwd", "repo", "contract"], "Terminate the current generation while keeping the projection identity and tell ledger."),
     log: command("log", "Render a contract ledger", ["keiyaku log [-C|--cwd DIR] [--repo DIR] [--contract ADDR]", "keiyaku @addr log [-C|--cwd DIR] [--repo DIR]"], "none", ["cwd", "repo", "contract"], "Read a contract ledger."),
     akuma: command("akuma", "Inspect Akuma profiles", ["keiyaku akuma list|show"], "none", [], "Inspect configured helper profiles.", {
         subcommands: ["list", "ls", "show"],
@@ -84,6 +85,7 @@ export function renderCliHelp(version) {
         "  wait       Wait for an akuma projection.",
         "  revive     Revive an Akuma helper session.",
         "  tell       Send intent to an Akuma projection.",
+        "  kill       Stop the current Akuma generation.",
         "  log        Render a contract ledger.",
         "  akuma      Inspect helper profiles.",
         "  skills     Install bundled official skills.",

package/build/cli/index.js

@@ -35,6 +35,7 @@ import { buildBindDraftResponse, buildBindResponse, buildForfeitResponse, format
 import { buildCallResponse, renderAdoptedLaunchReceipt } from "./render/call.js";
 import { projectionDir, writeInboxTell } from "../core/projection-core.js";
 import { assertTellEffortSupported, tellProjection } from "../core/projection-wake.js";
+import { killProjectionGeneration } from "../core/projection-kill.js";
 import { resolveProjectionAddress } from "./projection-address.js";
 import { waitForProjection } from "../core/projection-wait.js";
 import { buildWaitResponse } from "./render/wait.js";
@@ -233,6 +234,27 @@ const CLI_COMMAND_SPECS = {
         };
         return address ? await withResolvedAddress(address, operation) : await operation();
     }),
+    kill: commandSpec("kill", async (_stdin, flags, _signal, positional) => {
+        const cwd = flags.contractId ? await repositoryDirectory(flags) : await projectDirectory(flags);
+        const [projectionAddress] = positional;
+        if (!projectionAddress)
+            throw new FlowError("EMPTY_PARAM", "kill requires a projection address");
+        const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
+        const operation = async () => {
+            const projection = await resolveProjectionAddress({
+                cwd,
+                address: projectionAddress,
+                scope: address,
+                verb: "kill",
+            });
+            const result = killProjectionGeneration(projectionDir(cwd, projection.id));
+            const line = result.status === "killed"
+                ? `× killed ${projection.id}`
+                : `· already resting ${projection.id}`;
+            return textResponse(line);
+        };
+        return address ? await withResolvedAddress(address, operation) : await operation();
+    }),
     log: commandSpec("log", async (_stdin, flags) => {
         const cwd = await repositoryDirectory(flags);
         const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);

package/build/cli/parse.js

@@ -9,6 +9,7 @@ const COMMISSION_SELECTOR_COMMANDS = new Set([
     "call",
     "wait",
     "tell",
+    "kill",
     "log",
     "renew",
     "petition",
@@ -21,6 +22,7 @@ const CLI_COMMAND_ORDER = [
     "revive",
     "wait",
     "tell",
+    "kill",
     "log",
     "akuma list",
     "akuma ls",
@@ -45,6 +47,7 @@ const COMMAND_FLAGS = {
     revive: ["cwd", "repo", "model", "effort"],
     wait: ["cwd", "repo", "contract", "timeout"],
     tell: ["cwd", "repo", "contract", "effort"],
+    kill: ["cwd", "repo", "contract"],
     log: ["cwd", "repo", "contract"],
     akuma: [],
     "akuma ls": ["cwd", "repo"],
@@ -99,6 +102,8 @@ export function commandPositionalRange(command) {
         return { min: 1, max: 1, label: "<projection-address>" };
     if (command === "tell")
         return { min: 2, max: 2, label: "<projection> <message>" };
+    if (command === "kill")
+        return { min: 1, max: 1, label: "<projection-address>" };
     if (isCallCommand(command))
         return { min: 0, max: 1 };
     return { min: 0, max: 0 };

package/build/cli/skills-install.js

@@ -4,10 +4,12 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { FlowError, asMessage } from "../flow-error.js";
+import { VERSION } from "../generated/version.js";
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = path.resolve(MODULE_DIR, "../..");
 const OFFICIAL_SKILLS = ["keiyaku", "keiyaku-akuma"];
 const SKILL_ROOT = path.join(PACKAGE_ROOT, "skills");
+const INSTALL_MARKER = ".keiyaku-skill-owned.json";
 function skillSource(skill) {
     return path.join(SKILL_ROOT, skill);
 }
@@ -50,6 +52,76 @@ function objectKind(stat) {
         return "directory";
     return "other";
 }
+function updateHashField(hash, value) {
+    const bytes = typeof value === "string" ? Buffer.from(value, "utf8") : value;
+    const length = Buffer.allocUnsafe(4);
+    length.writeUInt32BE(bytes.length);
+    hash.update(length);
+    hash.update(bytes);
+}
+async function contentHash(root) {
+    const hash = crypto.createHash("sha256");
+    const walk = async (directory, relativeDirectory) => {
+        const entries = await fs.readdir(directory, { withFileTypes: true });
+        entries.sort((left, right) => Buffer.compare(Buffer.from(left.name, "utf8"), Buffer.from(right.name, "utf8")));
+        for (const entry of entries) {
+            const relative = relativeDirectory ? `${relativeDirectory}/${entry.name}` : entry.name;
+            if (relative === INSTALL_MARKER)
+                continue;
+            const absolute = path.join(directory, entry.name);
+            const stat = await fs.lstat(absolute);
+            const kind = stat.isDirectory() ? "directory"
+                : stat.isFile() ? "file"
+                    : stat.isSymbolicLink() ? "symlink"
+                        : "other";
+            updateHashField(hash, kind);
+            updateHashField(hash, relative);
+            if (kind === "file")
+                updateHashField(hash, await fs.readFile(absolute));
+            if (kind === "symlink")
+                updateHashField(hash, await fs.readlink(absolute));
+            if (kind === "other")
+                updateHashField(hash, `${stat.mode}:${stat.rdev}`);
+            if (kind === "directory")
+                await walk(absolute, relative);
+        }
+    };
+    await walk(root, "");
+    return hash.digest("hex");
+}
+function validMarker(value, skill) {
+    if (!value || typeof value !== "object")
+        return false;
+    const marker = value;
+    return marker.kind === "official-skill-copy"
+        && marker.skill === skill
+        && typeof marker.sourceVersion === "string"
+        && typeof marker.contentHash === "string"
+        && /^[0-9a-f]{64}$/.test(marker.contentHash);
+}
+async function readInstallMarker(target, skill) {
+    try {
+        const markerPath = path.join(target, INSTALL_MARKER);
+        if (!(await fs.lstat(markerPath)).isFile())
+            return undefined;
+        const marker = JSON.parse(await fs.readFile(markerPath, "utf8"));
+        return validMarker(marker, skill) ? marker : undefined;
+    }
+    catch (error) {
+        if (isMissing(error) || error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
+async function writeInstallMarker(target, skill, hash) {
+    const marker = {
+        kind: "official-skill-copy",
+        skill,
+        sourceVersion: VERSION,
+        contentHash: hash,
+    };
+    await fs.writeFile(path.join(target, INSTALL_MARKER), `${JSON.stringify(marker, null, 2)}\n`, "utf8");
+}
 async function classifyTarget(skill, target, canonicalSource) {
     let stat;
     try {
@@ -61,21 +133,39 @@ async function classifyTarget(skill, target, canonicalSource) {
         throw error;
     }
     const kind = objectKind(stat);
-    if (!stat.isSymbolicLink()) {
-        return { skill, path: target, source: canonicalSource, kind: "foreign", foreignIdentity: { kind, dev: stat.dev, ino: stat.ino } };
-    }
-    const originalLink = await fs.readlink(target);
-    try {
-        const resolved = await fs.realpath(path.resolve(path.dirname(target), originalLink));
-        return resolved === canonicalSource
-            ? { skill, path: target, source: canonicalSource, kind: "owned", originalLink }
-            : { skill, path: target, source: canonicalSource, kind: "foreign", originalLink, foreignIdentity: { kind, dev: stat.dev, ino: stat.ino, link: originalLink } };
-    }
-    catch (error) {
-        if (isMissing(error))
-            return { skill, path: target, source: canonicalSource, kind: "foreign", originalLink, foreignIdentity: { kind, dev: stat.dev, ino: stat.ino, link: originalLink } };
-        throw error;
+    if (stat.isDirectory()) {
+        const marker = await readInstallMarker(target, skill);
+        if (marker) {
+            const installedHash = await contentHash(target);
+            if (installedHash === marker.contentHash) {
+                const sourceHash = await contentHash(canonicalSource);
+                return {
+                    skill,
+                    path: target,
+                    source: canonicalSource,
+                    kind: "owned",
+                    needsUpgrade: marker.sourceVersion !== VERSION || marker.contentHash !== sourceHash,
+                };
+            }
+            return {
+                skill,
+                path: target,
+                source: canonicalSource,
+                kind: "foreign",
+                collisionReason: "modified",
+                foreignIdentity: { kind, dev: stat.dev, ino: stat.ino },
+            };
+        }
     }
+    const link = stat.isSymbolicLink() ? await fs.readlink(target) : undefined;
+    return {
+        skill,
+        path: target,
+        source: canonicalSource,
+        kind: "foreign",
+        collisionReason: "foreign",
+        foreignIdentity: { kind, dev: stat.dev, ino: stat.ino, link },
+    };
 }
 async function ensureParent(parent, createdDirectories) {
     const absentBeforeMutation = [];
@@ -159,9 +249,8 @@ async function rollbackAndVerify(originalError, states, createdDirectories) {
         }
         else if (state.kind === "owned") {
             try {
-                const link = await fs.readlink(state.path);
-                const resolved = await fs.realpath(path.resolve(path.dirname(state.path), link));
-                if (link !== state.originalLink || resolved !== state.source) {
+                const marker = await readInstallMarker(state.path, state.skill);
+                if (!marker || await contentHash(state.path) !== marker.contentHash) {
                     failures.push(`owned target changed at ${state.path}`);
                 }
             }
@@ -210,17 +299,21 @@ export async function installOfficialSkills(force = false) {
     }
     const collisions = states.filter((state) => state.kind === "foreign");
     if (collisions.length > 0 && !force) {
-        throw new FlowError("EMPTY_PARAM", `Foreign skill target already exists at ${collisions.map((state) => state.path).join(", ")}. Re-run with -f or --force to replace it.`);
+        const details = collisions.map((state) => state.collisionReason === "modified"
+            ? `${state.path} (owned fact exists but copied content was modified)`
+            : `${state.path} (foreign target or missing ownership fact)`);
+        throw new FlowError("EMPTY_PARAM", `Skill target collision at ${details.join(", ")}. Re-run with -f or --force to replace it.`);
     }
     const createdDirectories = [];
     try {
         for (const state of states) {
-            if (state.kind === "owned")
+            if (state.kind === "owned" && !state.needsUpgrade)
                 continue;
             await ensureParent(path.dirname(state.path), createdDirectories);
             state.temp = siblingArtifact(state.path, "tmp");
-            await fs.symlink(state.source, state.temp, "dir");
-            if (state.kind === "foreign") {
+            await fs.cp(state.source, state.temp, { recursive: true, errorOnExist: true, force: false });
+            await writeInstallMarker(state.temp, state.skill, await contentHash(state.temp));
+            if (state.kind === "foreign" || state.kind === "owned") {
                 state.backup = siblingArtifact(state.path, "backup");
                 await fs.rename(state.path, state.backup);
             }
@@ -248,7 +341,7 @@ export async function installOfficialSkills(force = false) {
             skill: state.skill,
             path: state.path,
             source: state.source,
-            status: state.kind === "owned" ? "owned" : "installed",
+            status: state.installed ? "installed" : "owned",
         })),
         warnings,
     };

package/build/core/projection-kill.js

@@ -0,0 +1,26 @@
+import { openProjectionGenerationStore } from "./projection-generation-store.js";
+export function killProjectionGeneration(projectionDirectory, nowMs = Date.now()) {
+    const store = openProjectionGenerationStore(projectionDirectory);
+    try {
+        const current = store.readCurrentGeneration();
+        if (!current)
+            return { status: "already-resting" };
+        if (current.verdict) {
+            return { status: "already-resting", executionId: current.launch.executionId };
+        }
+        const transition = store.verdictIfOpen({
+            executionId: current.launch.executionId,
+            verdict: "completed",
+            facts: {
+                operatorAction: "kill",
+                killedAt: new Date(nowMs).toISOString(),
+            },
+        });
+        return transition.status === "committed"
+            ? { status: "killed", executionId: current.launch.executionId }
+            : { status: "already-resting", executionId: current.launch.executionId };
+    }
+    finally {
+        store.close();
+    }
+}

package/build/core/projection-wake.js

@@ -116,6 +116,9 @@ export async function tellProjection(projectionDirectory, effort) {
                 ? await startCommittedSuccessor(projectionDirectory, successorExecutionId)
                 : "pending";
         }
+        if (life.phase !== "done") {
+            return "pending";
+        }
         const transition = store.launchIfSettled({
             executionId: successorExecutionId,
             facts,

package/build/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/generate-version.mjs
-export const VERSION = "2.8.1";
+export const VERSION = "2.8.3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "2.8.1",
+  "version": "2.8.3",
   "description": "CLI for running iterative keiyaku workflows with Codex subagents.",
   "license": "MIT",
   "type": "module",