@kylecheng3146/agent-ops 0.1.1 → 0.1.3

package/dist/runtime/src/install/probes.js

@@ -0,0 +1,68 @@
+import { buildClaudeHookSettings } from "../adapters/claude/config.js";
+import { buildCodexHookConfig } from "../adapters/codex/config.js";
+import { resolveProfiles } from "./profiles.js";
+const CLAUDE_HOOK_MARKER = "--managed-by=agent-ops";
+const CODEX_COMMAND_PREFIX = "agent-ops hook codex ";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasManagedHandler(source, events, isManaged) {
+    if (!isRecord(source) || !isRecord(source.hooks)) {
+        return false;
+    }
+    const registered = source.hooks;
+    return events.every((event) => {
+        const groups = registered[event];
+        return (Array.isArray(groups) &&
+            groups.some((group) => isRecord(group) &&
+                Array.isArray(group.hooks) &&
+                group.hooks.some(isManaged)));
+    });
+}
+function isManagedClaudeHandler(handler) {
+    return (isRecord(handler) &&
+        Array.isArray(handler.args) &&
+        handler.args.includes(CLAUDE_HOOK_MARKER));
+}
+function isManagedCodexHandler(handler) {
+    return (isRecord(handler) &&
+        typeof handler.command === "string" &&
+        handler.command.startsWith(CODEX_COMMAND_PREFIX));
+}
+/**
+ * Hook registration is satisfied when every hook event implied by the
+ * installed profiles carries an agent-ops owned handler for every installed
+ * harness. Installations without hook capabilities have nothing to register.
+ */
+export function hookRegistrationSatisfied(input) {
+    const { capabilities } = resolveProfiles(input.profiles);
+    const claudeEvents = Object.keys(buildClaudeHookSettings(capabilities, "probe").hooks);
+    const codexEvents = Object.keys(buildCodexHookConfig(capabilities).hooks);
+    if (claudeEvents.length === 0 && codexEvents.length === 0) {
+        return true;
+    }
+    if (input.harness !== "codex" &&
+        !hasManagedHandler(input.claudeSettings, claudeEvents, isManagedClaudeHandler)) {
+        return false;
+    }
+    return (input.harness === "claude" ||
+        hasManagedHandler(input.codexHooks, codexEvents, isManagedCodexHandler));
+}
+/**
+ * Smoke availability stays UNKNOWN until the repository declares a
+ * verification command; the toolkit never invents one.
+ */
+export function smokeAvailabilityStatus(config) {
+    return config.verification.commands.length > 0 ? "PASS" : "UNKNOWN";
+}
+/**
+ * Installation approval never grants trust, so an ungranted repository is
+ * unconfigured rather than broken. A stale binding is a real failure.
+ */
+export function repositoryTrustStatus(trust) {
+    return trust === "TRUSTED"
+        ? "PASS"
+        : trust === "STALE"
+            ? "FAIL"
+            : "UNKNOWN";
+}

package/dist/runtime/src/install/uninstall.js

@@ -5,6 +5,7 @@ import { removeManagedBlock } from "../fs/managed-block.js";
 import { parseInstallManifest } from "../fs/manifest.js";
 import { AgentOpsError, resolveContainedPath } from "../fs/paths.js";
 import { FileTransaction } from "../fs/transaction.js";
+import { planHookRemoval } from "./hooks.js";
 import { assertExpectedManagedBlock, assertSupportedManifestOwnership } from "./ownership.js";
 const MANIFEST_PATH = ".agent-ops/manifest.json";
 const MAX_UNINSTALL_FILE_BYTES = 1024 * 1024;
@@ -130,6 +131,25 @@ export async function createUninstallPlan(root) {
         });
     }
     operations.push(...await planMarkerFiles(root, manifest.markers, expectedMarkers));
+    for (const hook of manifest.hooks ?? []) {
+        const current = await readCurrentFile(root, hook.path);
+        if (current === null) {
+            continue;
+        }
+        const removal = planHookRemoval(hook, current.content);
+        operations.push(removal.content === null
+            ? {
+                kind: "remove",
+                path: hook.path,
+                expectedHash: current.hash
+            }
+            : {
+                kind: "write",
+                path: hook.path,
+                content: removal.content,
+                expectedHash: current.hash
+            });
+    }
     operations.push({
         kind: "remove",
         path: MANIFEST_PATH,
@@ -149,6 +169,7 @@ function allowedPaths(plan) {
     return new Set([
         ...plan.manifest.artifacts.map(({ path }) => path.toLowerCase()),
         ...plan.manifest.markers.map(({ path }) => path.toLowerCase()),
+        ...(plan.manifest.hooks ?? []).map(({ path }) => path.toLowerCase()),
         MANIFEST_PATH
     ]);
 }
@@ -187,6 +208,13 @@ async function validateUninstalled(root, manifest) {
             throw new AgentOpsError("UNINSTALL_VALIDATION_FAILED", `Managed block still exists: ${marker.path}`);
         }
     }
+    for (const hook of manifest.hooks ?? []) {
+        const current = await readCurrentFile(root, hook.path);
+        if (current !== null &&
+            planHookRemoval(hook, current.content).content !== current.content) {
+            throw new AgentOpsError("UNINSTALL_VALIDATION_FAILED", `Managed hook handlers still exist: ${hook.path}`);
+        }
+    }
     if (await readCurrentFile(root, MANIFEST_PATH) !== null) {
         throw new AgentOpsError("UNINSTALL_VALIDATION_FAILED", "Installation manifest still exists.");
     }

package/dist/runtime/src/install/update.js

@@ -107,6 +107,9 @@ export async function createUpdatePlan(options) {
         profiles: configPreview.migrated.profiles,
         adapters: options.adapters,
         toolkitVersion: targetVersion,
+        ...(options.hookRuntimePath === undefined
+            ? {}
+            : { hookRuntimePath: options.hookRuntimePath }),
         existingConfig: {
             value: configPreview.migrated,
             sourceHash: configPreview.sourceHash

package/dist/runtime/src/schema/validate.js

@@ -6,6 +6,12 @@ const PROFILE_VALUES = new Set(["advisory", "core", "guardrails"]);
 const EVIDENCE_KINDS = new Set(["exit-code", "file", "test-count"]);
 const SCOPE_VALUES = new Set(["project", "user"]);
 const HARNESS_VALUES = new Set(["both", "claude", "codex"]);
+const HOOK_HARNESS_VALUES = new Set(["claude", "codex"]);
+const HOOK_EVENT_VALUES = new Set([
+    "SessionStart",
+    "PreToolUse",
+    "Stop"
+]);
 const MAX_TIMEOUT_MS = 2_147_483_647;
 const MAX_EXIT_CODE = 4_294_967_295;
 function failure(code, path, message) {
@@ -520,10 +526,40 @@ function validateManagedMarker(value, path) {
     }
     return success(value);
 }
+function validateManagedHook(value, path) {
+    if (!isRecord(value)) {
+        return failure("INVALID_TYPE", path, "Expected a managed hook record.");
+    }
+    const unknown = unknownFieldFailure(value, ["events", "harness", "id", "owner", "path"], path);
+    if (unknown !== undefined) {
+        return unknown;
+    }
+    if (!isIdentifier(value.id)) {
+        return failure("INVALID_ID", `${path}.id`, "Invalid managed entry ID.");
+    }
+    if (!isSafeRelativePath(value.path) || value.path === ".") {
+        return failure("INVALID_RELATIVE_PATH", `${path}.path`, "Managed paths must be project-relative.");
+    }
+    if (typeof value.harness !== "string" ||
+        !HOOK_HARNESS_VALUES.has(value.harness)) {
+        return failure("INVALID_HARNESS", `${path}.harness`, "Hook records must name a single harness.");
+    }
+    if (!isStringArray(value.events) ||
+        value.events.length === 0 ||
+        new Set(value.events).size !== value.events.length ||
+        value.events.some((event) => !HOOK_EVENT_VALUES.has(event))) {
+        return failure("INVALID_HOOK_EVENTS", `${path}.events`, "Hook records must list distinct supported events.");
+    }
+    if (value.owner !== "agent-ops") {
+        return failure("INVALID_OWNER", `${path}.owner`, "Managed entries must be owned by agent-ops.");
+    }
+    return success(value);
+}
 export function validateManifest(value) {
     const root = validateRoot(value, [
         "artifacts",
         "harness",
+        "hooks",
         "markers",
         "schemaVersion",
         "scope"
@@ -580,5 +616,26 @@ export function validateManifest(value) {
         markerBoundaries.add(startBoundary);
         markerBoundaries.add(endBoundary);
     }
+    if (root.hooks !== undefined) {
+        if (!Array.isArray(root.hooks)) {
+            return failure("INVALID_TYPE", "$.hooks", "hooks must be an array.");
+        }
+        const hookPaths = new Set();
+        for (const [index, hookValue] of root.hooks.entries()) {
+            const hook = validateManagedHook(hookValue, `$.hooks[${index}]`);
+            if (!hook.ok) {
+                return hook;
+            }
+            const hookPathKey = hook.value.path.toLowerCase();
+            if (entryIds.has(hook.value.id)) {
+                return failure("DUPLICATE_ID", `$.hooks[${index}].id`, `Duplicate manifest entry ID: ${hook.value.id}`);
+            }
+            if (artifactPaths.has(hookPathKey) || hookPaths.has(hookPathKey)) {
+                return failure("DUPLICATE_OWNERSHIP", `$.hooks[${index}].path`, `Hook path is owned more than once: ${hook.value.path}`);
+            }
+            entryIds.add(hook.value.id);
+            hookPaths.add(hookPathKey);
+        }
+    }
     return success(root);
 }

package/dist/runtime/src/security/permissions.js

@@ -241,7 +241,9 @@ async function readWindowsProcessIdentity(processId) {
         ], {
             encoding: "utf8",
             maxBuffer: 4096,
-            timeout: 2000,
+            // ponytail: cold PowerShell start on a loaded machine routinely
+            // passes two seconds; the lock budget above still bounds the wait.
+            timeout: 10_000,
             windowsHide: true
         });
         const startedAt = result.stdout.trim();
@@ -251,10 +253,27 @@ async function readWindowsProcessIdentity(processId) {
         return null;
     }
 }
+/**
+ * A live process cannot change its own start time, so a successful self
+ * lookup never expires. Every other entry keeps the short TTL: foreign
+ * process IDs get recycled, and a failed self lookup must stay retryable
+ * instead of pinning the fallback identity for the whole run.
+ */
+export function reuseCachedProcessIdentity(entry, processId, selfProcessId, now) {
+    if (entry === undefined) {
+        return false;
+    }
+    if (processId === selfProcessId &&
+        entry.identity !== null &&
+        !entry.identity.startsWith("runtime:")) {
+        return true;
+    }
+    return now - entry.checkedAt <= PROCESS_IDENTITY_CACHE_MS;
+}
 async function readProcessIdentity(processId) {
     const cached = processIdentityCache.get(processId);
-    if (cached !== undefined &&
-        Date.now() - cached.checkedAt <= PROCESS_IDENTITY_CACHE_MS) {
+    if (reuseCachedProcessIdentity(cached, processId, process.pid, Date.now()) &&
+        cached !== undefined) {
         return cached.identity;
     }
     let identity;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kylecheng3146/agent-ops",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Evidence-driven development loops for Codex and Claude Code",
   "type": "module",
   "license": "MIT",

package/schemas/manifest.schema.json

@@ -26,6 +26,12 @@
       "items": {
         "$ref": "#/$defs/managedMarker"
       }
+    },
+    "hooks": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/managedHook"
+      }
     }
   },
   "$defs": {
@@ -104,6 +110,33 @@
         }
       }
     },
+    "managedHook": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "path", "harness", "events", "owner"],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/id"
+        },
+        "path": {
+          "$ref": "#/$defs/relativePath"
+        },
+        "harness": {
+          "enum": ["codex", "claude"]
+        },
+        "events": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "enum": ["SessionStart", "PreToolUse", "Stop"]
+          }
+        },
+        "owner": {
+          "const": "agent-ops"
+        }
+      }
+    },
     "nonEmptyString": {
       "type": "string",
       "pattern": "[^\\s\\u0000]",