@jitsusama/agentic-harness.core 0.6.0 → 0.6.1

package/dist/attribution/commit-hook.d.ts

@@ -42,11 +42,14 @@ export interface HookInstall {
 export declare function installCommitHook(repoRoot: string, options: CommitHookOptions): HookInstall;
 /**
  * Ensure the hook is installed in the repo containing dir, at most
- * once per repo root. Resolves the repo, records it in `installed`
- * so later commands in the same repo are skipped, and installs
- * best-effort. A directory outside any git repo is a no-op. This is
- * how hook coverage follows the session into repos it later cds
- * into, rather than only the repo the session started in.
+ * once per repo. Records both dir and its repo root in `installed`,
+ * so a later command from either asks git nothing, and installs
+ * best-effort. A directory outside any git repo is a no-op and is
+ * not remembered, so a repo initialised there later is still
+ * covered. This is how hook coverage follows the session into repos
+ * it later cds into, rather than only the repo the session started
+ * in. Each git call is a synchronous spawn on the command path, so
+ * a first visit costs one and a repeat costs none.
  */
 export declare function ensureCommitHook(dir: string, installed: Set<string>, options: CommitHookOptions): void;
 /** The git repository root containing dir, or null when there is none. */

package/dist/attribution/commit-hook.js

@@ -46,20 +46,20 @@ git interpret-trailers --in-place --trailer ${options.trailerExpr} "$msg_file"
  * hook. A no-op when this adapter's hook is already installed.
  */
 export function installCommitHook(repoRoot, options) {
+    const layout = locateHooks(repoRoot);
+    if (!layout)
+        return { installed: false, reason: "not a git repo" };
+    return installInto(layout, options);
+}
+/** Install the hook into a repo whose hooks have been located. */
+function installInto({ hooksDir, customHooksPath }, options) {
     // A custom core.hooksPath means a hook manager (husky and the
     // like) or a shared, possibly version-controlled hooks directory
     // owns the hooks. Leave it alone rather than write this adapter's
     // hook into a directory it does not own.
-    if (hasCustomHooksPath(repoRoot)) {
+    if (customHooksPath) {
         return { installed: false, reason: "custom core.hooksPath configured" };
     }
-    let hooksDir;
-    try {
-        hooksDir = resolveHooksDir(repoRoot);
-    }
-    catch (error) {
-        return { installed: false, reason: `not a git repo: ${String(error)}` };
-    }
     const target = join(hooksDir, "prepare-commit-msg");
     if (existsSync(target) &&
         readFileSync(target, "utf8").includes(options.marker)) {
@@ -82,41 +82,66 @@ export function installCommitHook(repoRoot, options) {
     chmodSync(target, 0o755);
     return { installed: true };
 }
-/** Whether the repo configures a custom core.hooksPath. */
-function hasCustomHooksPath(repoRoot) {
-    try {
-        const value = execFileSync("git", ["-C", repoRoot, "config", "--get", "core.hooksPath"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-        return value.length > 0;
-    }
-    catch {
-        // git config exits non-zero when the key is unset: no custom path.
-        return false;
-    }
-}
 /**
  * Ensure the hook is installed in the repo containing dir, at most
- * once per repo root. Resolves the repo, records it in `installed`
- * so later commands in the same repo are skipped, and installs
- * best-effort. A directory outside any git repo is a no-op. This is
- * how hook coverage follows the session into repos it later cds
- * into, rather than only the repo the session started in.
+ * once per repo. Records both dir and its repo root in `installed`,
+ * so a later command from either asks git nothing, and installs
+ * best-effort. A directory outside any git repo is a no-op and is
+ * not remembered, so a repo initialised there later is still
+ * covered. This is how hook coverage follows the session into repos
+ * it later cds into, rather than only the repo the session started
+ * in. Each git call is a synchronous spawn on the command path, so
+ * a first visit costs one and a repeat costs none.
  */
 export function ensureCommitHook(dir, installed, options) {
-    const root = repoRootOf(dir);
-    if (!root || installed.has(root))
+    if (installed.has(dir))
+        return;
+    const layout = locateHooks(dir);
+    if (!layout)
         return;
-    installed.add(root);
+    installed.add(dir);
+    if (installed.has(layout.root))
+        return;
+    installed.add(layout.root);
     try {
-        installCommitHook(root, options);
+        installInto(layout, options);
     }
     catch {
         // Best-effort: never let hook installation break a command.
     }
 }
-/** Resolve the active hooks directory, honouring core.hooksPath. */
-function resolveHooksDir(repoRoot) {
-    const path = execFileSync("git", ["-C", repoRoot, "rev-parse", "--git-path", "hooks"], { encoding: "utf8" }).trim();
-    return isAbsolute(path) ? path : join(repoRoot, path);
+/**
+ * Locate the hooks of the repo containing dir with one git call, or
+ * null when dir is in no working tree. Git prints the default hooks
+ * path as the common dir plus `/hooks`, in the same form, so any
+ * other answer means core.hooksPath points somewhere else.
+ */
+function locateHooks(dir) {
+    let answer;
+    try {
+        answer = execFileSync("git", [
+            "-C",
+            dir,
+            "rev-parse",
+            "--show-toplevel",
+            "--git-common-dir",
+            "--git-path",
+            "hooks",
+        ], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    }
+    catch {
+        // Not in a working tree (or git unavailable): nothing to hook.
+        return null;
+    }
+    const [root, commonDir, hooks] = answer.trimEnd().split("\n");
+    if (!root || !commonDir || !hooks)
+        return null;
+    return {
+        root,
+        // Relative paths are relative to the directory git ran in.
+        hooksDir: isAbsolute(hooks) ? hooks : join(dir, hooks),
+        customHooksPath: hooks !== `${commonDir}/hooks`,
+    };
 }
 /** The git repository root containing dir, or null when there is none. */
 export function repoRootOf(dir) {

package/dist/internal/quest/process-liveness.d.ts

@@ -79,6 +79,11 @@ export declare function identityFromInspection(hostId: string, pid: number, insp
  * read a real start token: a session then carries no process identity
  * and its liveness falls back to recency, rather than a synthetic
  * token that a later probe would read as a dead mismatch.
+ *
+ * A process's own start token cannot change while it runs, so the
+ * first real reading is remembered: a session start attaches more
+ * than once and each reading is a synchronous `ps`. A failed reading
+ * is not remembered, so a transient failure is retried next time.
  */
 export declare function currentProcessIdentity(): ProcessIdentity | undefined;
 /**

package/dist/internal/quest/process-liveness.js

@@ -95,14 +95,26 @@ export function identityFromInspection(hostId, pid, inspection) {
         ? { hostId, pid, startToken: inspection.startToken }
         : undefined;
 }
+/** Memoized identity of this process, once one has been read. */
+let processIdentityCache;
 /**
  * Identity of the currently running pi process, for capture onto the
  * session it is attached to. Undefined when the OS reader could not
  * read a real start token: a session then carries no process identity
  * and its liveness falls back to recency, rather than a synthetic
  * token that a later probe would read as a dead mismatch.
+ *
+ * A process's own start token cannot change while it runs, so the
+ * first real reading is remembered: a session start attaches more
+ * than once and each reading is a synchronous `ps`. A failed reading
+ * is not remembered, so a transient failure is retried next time.
  */
 export function currentProcessIdentity() {
+    processIdentityCache ??= readProcessIdentity();
+    return processIdentityCache;
+}
+/** Read this process's identity from the OS. */
+function readProcessIdentity() {
     const identity = identityFromInspection(hostname(), process.pid, readStartToken(process.pid));
     if (!identity)
         return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jitsusama/agentic-harness.core",
-	"version": "0.6.0",
+	"version": "0.6.1",
 	"description": "Pi-agnostic business logic for agentic-harness: state machines, guardian decisions, quest/TDD domain model.",
 	"license": "MIT",
 	"type": "module",