@habitat-ai/cli 0.2.0

package/bin/run.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+
+import { fileURLToPath } from "node:url";
+import { executeHabitat } from "../dist/application.js";
+
+await executeHabitat({
+  appRoot: fileURLToPath(new URL("..", import.meta.url)),
+  workspaceRoot: process.cwd(),
+});

package/dist/application.d.ts

@@ -0,0 +1,14 @@
+/** Inputs fixed by one Habitat process activation. */
+export type ExecuteHabitatOptions = Readonly<{
+    appRoot: string;
+    workspaceRoot: string;
+    args?: string[];
+    development?: boolean;
+}>;
+/**
+ * Runs one native Oclif invocation over the app-selected Habitat client.
+ *
+ * Oclif owns command discovery and dispatch; this boundary supplies only the
+ * ready workspace client required by the Habitat command plugin.
+ */
+export declare function executeHabitat({ appRoot, workspaceRoot, args, development, }: ExecuteHabitatOptions): Promise<unknown>;

package/dist/application.js

@@ -0,0 +1,18 @@
+import { bindHabitatClient } from "@habitat-ai/plugin-cli/binding";
+import { execute, settings } from "@oclif/core";
+import { createHabitatClientForWorkspace } from "./composition.js";
+/**
+ * Runs one native Oclif invocation over the app-selected Habitat client.
+ *
+ * Oclif owns command discovery and dispatch; this boundary supplies only the
+ * ready workspace client required by the Habitat command plugin.
+ */
+export async function executeHabitat({ appRoot, workspaceRoot, args, development, }) {
+    settings.enableAutoTranspile = development === true;
+    const client = await createHabitatClientForWorkspace(workspaceRoot);
+    return execute({
+        ...(args === undefined ? {} : { args }),
+        ...(development === undefined ? {} : { development }),
+        loadOptions: bindHabitatClient({ root: appRoot }, client),
+    });
+}

package/dist/composition.d.ts

@@ -0,0 +1,8 @@
+import { type Client } from "@habitat-ai/service/client";
+/**
+ * Constructs the production Habitat client for one workspace.
+ *
+ * The app selects concrete Node providers here so the service and both
+ * projections remain provider-neutral and share one composition boundary.
+ */
+export declare function createHabitatClientForWorkspace(workspaceRoot: string): Promise<Client>;

package/dist/composition.js

@@ -0,0 +1,59 @@
+import { createRequire } from "node:module";
+import { NodeServices } from "@effect/platform-node";
+import { makeNodeGritRuleEvaluationResource } from "@habitat-ai/resource-rule-evaluation/providers/grit-effect-platform-node";
+import { makeNodeGitSourceInventoryResource } from "@habitat-ai/resource-source-inventory/providers/git-effect-platform-node";
+import { createClient } from "@habitat-ai/service/client";
+import { Effect, FileSystem, Path } from "effect";
+import { Type } from "typebox";
+import { Validator } from "typebox/schema";
+const require = createRequire(import.meta.url);
+const gritExecutable = require.resolve("@getgrit/cli/run-grit.js");
+const HABITAT_BLUEPRINT_PACK = "@habitat-ai/blueprints";
+const CommandTimeoutSchema = Type.Integer({ minimum: 1, maximum: 600_000 });
+const commandTimeoutValidator = new Validator({}, CommandTimeoutSchema);
+const commandTimeoutMs = decodeCommandTimeout(process.env.HABITAT_COMMAND_TIMEOUT_MS);
+const deps = Effect.runPromise(Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    return {
+        fileSystem,
+        path,
+        ruleEvaluation: makeNodeGritRuleEvaluationResource({
+            executable: gritExecutable,
+            timeoutMs: commandTimeoutMs,
+        }),
+        sourceInventory: makeNodeGitSourceInventoryResource(),
+    };
+}).pipe(Effect.provide(NodeServices.layer)));
+/**
+ * Constructs the production Habitat client for one workspace.
+ *
+ * The app selects concrete Node providers here so the service and both
+ * projections remain provider-neutral and share one composition boundary.
+ */
+export async function createHabitatClientForWorkspace(workspaceRoot) {
+    const ready = await deps;
+    const resolvedWorkspaceRoot = ready.path.resolve(workspaceRoot);
+    const workspaceRequire = createRequire(ready.path.join(resolvedWorkspaceRoot, "package.json"));
+    const packageJsonPath = workspaceRequire.resolve(`${HABITAT_BLUEPRINT_PACK}/package.json`);
+    return createClient({
+        deps: ready,
+        scope: { workspaceRoot: resolvedWorkspaceRoot },
+        config: {
+            policyPack: {
+                name: HABITAT_BLUEPRINT_PACK,
+                packageJsonPath,
+                manifestPath: ready.path.join(ready.path.dirname(packageJsonPath), "habitat-pack.json"),
+            },
+        },
+    });
+}
+function decodeCommandTimeout(input) {
+    if (input === undefined)
+        return 30_000;
+    const value = Number(input);
+    if (!commandTimeoutValidator.Check(value)) {
+        throw new Error("HABITAT_COMMAND_TIMEOUT_MS must be an integer from 1 through 600000.");
+    }
+    return value;
+}

package/dist/generators/init.cjs

@@ -0,0 +1,252 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/generators/init.ts
+var exports_init = {};
+__export(exports_init, {
+  default: () => initializeHabitat
+});
+module.exports = __toCommonJS(exports_init);
+var import_devkit2 = require("@nx/devkit");
+
+// ../../plugins/nx/habitat/src/initialization.ts
+var import_node_util = require("node:util");
+var import_devkit = require("@nx/devkit");
+var import_typebox = require("typebox");
+var import_schema = require("typebox/schema");
+var PACKAGE_PATH = "package.json";
+var CODEX_HOOKS_PATH = ".codex/hooks.json";
+var HabitatHookMarkerSchema = import_typebox.Type.Object({
+  identity: import_typebox.Type.String({
+    minLength: 1,
+    description: "Stable package-owned identity for one Habitat hook contribution."
+  }),
+  revision: import_typebox.Type.Integer({
+    minimum: 0,
+    description: "Monotonic payload revision for the named Habitat contribution."
+  })
+}, { additionalProperties: false, description: "Habitat hook ownership marker." });
+var HookGroupSchema = import_typebox.Type.Object({
+  _habitat: import_typebox.Type.Optional(HabitatHookMarkerSchema),
+  hooks: import_typebox.Type.Array(import_typebox.Type.Unknown(), {
+    description: "Ordered command contributions in one Codex hook group."
+  })
+}, { additionalProperties: true, description: "One consumer-owned Codex hook group." });
+var HabitatHookCommandSchema = import_typebox.Type.Object({
+  type: import_typebox.Type.Literal("command", {
+    description: "Codex hook handler kind owned by the Habitat initializer."
+  }),
+  command: import_typebox.Type.String({
+    minLength: 1,
+    description: "Installed Habitat command executed by the Codex hook."
+  }),
+  statusMessage: import_typebox.Type.String({
+    minLength: 1,
+    description: "Operator-facing status rendered while Habitat checks run."
+  }),
+  timeout: import_typebox.Type.Integer({
+    minimum: 1,
+    description: "Maximum seconds allowed for the Habitat hook command."
+  })
+}, { additionalProperties: false, description: "One Habitat-owned Codex hook command." });
+var HabitatOwnedHookGroupSchema = import_typebox.Type.Object({
+  _habitat: HabitatHookMarkerSchema,
+  hooks: import_typebox.Type.Array(HabitatHookCommandSchema, {
+    minItems: 1,
+    description: "Commands contributed by the installed Habitat package."
+  })
+}, { additionalProperties: false, description: "The named Habitat Codex hook contribution." });
+var CodexHooksSchema = import_typebox.Type.Object({
+  hooks: import_typebox.Type.Optional(import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.Array(HookGroupSchema), {
+    description: "Ordered hook groups keyed by Codex event identity."
+  }))
+}, { additionalProperties: true, description: "Consumer-owned Codex hook configuration." });
+var ConsumerPackageSchema = import_typebox.Type.Object({
+  trustedDependencies: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.String({ minLength: 1 }), {
+    description: "Package lifecycle scripts explicitly trusted by the Bun consumer."
+  }))
+}, { additionalProperties: true, description: "Nx consumer package metadata." });
+var hooksValidator = new import_schema.Validator({}, CodexHooksSchema);
+var packageValidator = new import_schema.Validator({}, ConsumerPackageSchema);
+function initializeHabitatConsumer(tree, binding) {
+  const nxJson = requireNxJson(tree);
+  const hooks = readHooks(tree);
+  const packageJson = readPackage(tree);
+  const nxPlan = planNxInitialization(nxJson, binding);
+  const hookPlan = planHookInitialization(hooks, binding);
+  const packagePlan = planPackageInitialization(packageJson, binding.gritPackage);
+  if (nxPlan.changed)
+    import_devkit.updateNxJson(tree, nxPlan.value);
+  if (hookPlan.changed)
+    import_devkit.writeJson(tree, CODEX_HOOKS_PATH, hookPlan.value);
+  if (packagePlan.changed)
+    import_devkit.writeJson(tree, PACKAGE_PATH, packagePlan.value);
+  return { packageChanged: packagePlan.changed };
+}
+function requireNxJson(tree) {
+  const nxJson = import_devkit.readNxJson(tree);
+  if (nxJson === null) {
+    throw new Error("Habitat initialization requires an Nx workspace with nx.json.");
+  }
+  return nxJson;
+}
+function readHooks(tree) {
+  if (!tree.exists(CODEX_HOOKS_PATH))
+    return { hooks: {} };
+  const input = import_devkit.readJson(tree, CODEX_HOOKS_PATH);
+  if (!hooksValidator.Check(input)) {
+    throw new Error(`${CODEX_HOOKS_PATH} is not a supported Codex hook document.`);
+  }
+  return input;
+}
+function readPackage(tree) {
+  if (!tree.exists(PACKAGE_PATH)) {
+    throw new Error("Habitat initialization requires an Nx workspace package.json.");
+  }
+  const input = import_devkit.readJson(tree, PACKAGE_PATH);
+  if (!packageValidator.Check(input)) {
+    throw new Error("package.json is not a supported Nx consumer package document.");
+  }
+  return input;
+}
+function planNxInitialization(nxJson, binding) {
+  const plugins = nxJson.plugins ?? [];
+  const matches = plugins.filter((plugin) => hasPluginIdentity(plugin, binding.nxPlugin) || binding.predecessorNxPlugins.some((predecessor) => hasPluginIdentity(plugin, typeof predecessor === "string" ? predecessor : predecessor.plugin)));
+  if (matches.length > 1) {
+    throw new Error("nx.json contains multiple Habitat Nx plugin registrations.");
+  }
+  const match = matches[0];
+  if (match === binding.nxPlugin)
+    return { changed: false, value: nxJson };
+  if (match !== undefined && !binding.predecessorNxPlugins.some((predecessor) => import_node_util.isDeepStrictEqual(predecessor, match))) {
+    throw new Error("nx.json contains an incompatible Habitat Nx plugin registration.");
+  }
+  const nextPlugins = match === undefined ? [...plugins, binding.nxPlugin] : plugins.map((plugin) => plugin === match ? binding.nxPlugin : plugin);
+  return { changed: true, value: { ...nxJson, plugins: nextPlugins } };
+}
+function planHookInitialization(hooks, binding) {
+  const location = oneOwnedHookLocation(hooks, binding);
+  if (location !== undefined && import_node_util.isDeepStrictEqual(location.group, binding.hook)) {
+    return { changed: false, value: hooks };
+  }
+  if (location !== undefined && !binding.predecessorHooks.some((predecessor) => import_node_util.isDeepStrictEqual(predecessor, location.group))) {
+    throw new Error(`${CODEX_HOOKS_PATH} contains an incompatible Habitat hook contribution.`);
+  }
+  const events = hooks.hooks ?? {};
+  const stop = events.Stop ?? [];
+  const nextStop = location === undefined ? [...stop, binding.hook] : stop.map((group, index) => index === location.index ? binding.hook : group);
+  return {
+    changed: true,
+    value: { ...hooks, hooks: { ...events, Stop: nextStop } }
+  };
+}
+function planPackageInitialization(packageJson, gritPackage) {
+  const trusted = packageJson.trustedDependencies ?? [];
+  const matches = trusted.filter((dependency) => dependency === gritPackage);
+  if (matches.length > 1) {
+    throw new Error(`package.json contains duplicate ${gritPackage} trust entries.`);
+  }
+  if (matches.length === 1)
+    return { changed: false, value: packageJson };
+  return {
+    changed: true,
+    value: { ...packageJson, trustedDependencies: [...trusted, gritPackage] }
+  };
+}
+function oneOwnedHookLocation(hooks, binding) {
+  const identity = binding.hook._habitat.identity;
+  const locations = Object.entries(hooks.hooks ?? {}).flatMap(([event, groups]) => groups.flatMap((group, index) => {
+    const marked = group._habitat?.identity === identity;
+    const predecessor = binding.predecessorHooks.some((candidate) => import_node_util.isDeepStrictEqual(candidate, group));
+    return marked || predecessor ? [{ event, group, index }] : [];
+  }));
+  if (locations.length > 1) {
+    throw new Error(`${CODEX_HOOKS_PATH} contains multiple Habitat hook contributions.`);
+  }
+  const location = locations[0];
+  if (location !== undefined && location.event !== "Stop") {
+    throw new Error(`${CODEX_HOOKS_PATH} contains a Habitat hook contribution outside Stop.`);
+  }
+  return location;
+}
+function hasPluginIdentity(plugin, identity) {
+  return plugin === identity || typeof plugin === "object" && plugin.plugin === identity;
+}
+
+// src/nx-generators.ts
+var habitatConsumerBinding = {
+  gritPackage: "@getgrit/cli",
+  nxPlugin: "@habitat-ai/cli/nx-plugin",
+  predecessorNxPlugins: [
+    {
+      plugin: "@habitat/cli/nx-plugin",
+      options: { checkTargetName: "check:policy" }
+    }
+  ],
+  hook: {
+    _habitat: { identity: "@habitat-ai/cli:agent-stop", revision: 1 },
+    hooks: [
+      {
+        type: "command",
+        command: 'bash -lc \'repo="${CODEX_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-}}"; if [ -n "$repo" ]; then repo="$(git -C "$repo" rev-parse --show-toplevel 2>/dev/null)"; else repo="$(git rev-parse --show-toplevel 2>/dev/null)"; fi && cd "$repo" 2>/dev/null || { printf "%s\\n" "Habitat agent-stop hook must run inside the repository worktree." >&2; exit 2; }; bunx --bun --no-install --package @habitat-ai/cli habitat hook agent-stop\'',
+        timeout: 120,
+        statusMessage: "Checking Habitat structure laws"
+      }
+    ]
+  },
+  predecessorHooks: [
+    {
+      hooks: [
+        {
+          type: "command",
+          command: 'bash -lc \'repo="${CODEX_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-}}"; if [ -n "$repo" ]; then repo="$(git -C "$repo" rev-parse --show-toplevel 2>/dev/null)"; else repo="$(git rev-parse --show-toplevel 2>/dev/null)"; fi && cd "$repo" 2>/dev/null || { printf "%s\\n" "Habitat agent-stop hook must run inside the repository worktree." >&2; exit 2; }; bun habitat hook agent-stop\'',
+          timeout: 120,
+          statusMessage: "Checking Habitat structure laws"
+        }
+      ]
+    }
+  ]
+};
+
+// src/generators/init.ts
+function initializeHabitat(tree) {
+  const result = initializeHabitatConsumer(tree, habitatConsumerBinding);
+  if (!result.packageChanged)
+    return;
+  return () => import_devkit2.installPackagesTask(tree);
+}

package/dist/generators/remove-hook.cjs

@@ -0,0 +1,191 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/generators/remove-hook.ts
+var exports_remove_hook = {};
+__export(exports_remove_hook, {
+  default: () => removeHook
+});
+module.exports = __toCommonJS(exports_remove_hook);
+
+// ../../plugins/nx/habitat/src/initialization.ts
+var import_node_util = require("node:util");
+var import_devkit = require("@nx/devkit");
+var import_typebox = require("typebox");
+var import_schema = require("typebox/schema");
+var CODEX_HOOKS_PATH = ".codex/hooks.json";
+var HabitatHookMarkerSchema = import_typebox.Type.Object({
+  identity: import_typebox.Type.String({
+    minLength: 1,
+    description: "Stable package-owned identity for one Habitat hook contribution."
+  }),
+  revision: import_typebox.Type.Integer({
+    minimum: 0,
+    description: "Monotonic payload revision for the named Habitat contribution."
+  })
+}, { additionalProperties: false, description: "Habitat hook ownership marker." });
+var HookGroupSchema = import_typebox.Type.Object({
+  _habitat: import_typebox.Type.Optional(HabitatHookMarkerSchema),
+  hooks: import_typebox.Type.Array(import_typebox.Type.Unknown(), {
+    description: "Ordered command contributions in one Codex hook group."
+  })
+}, { additionalProperties: true, description: "One consumer-owned Codex hook group." });
+var HabitatHookCommandSchema = import_typebox.Type.Object({
+  type: import_typebox.Type.Literal("command", {
+    description: "Codex hook handler kind owned by the Habitat initializer."
+  }),
+  command: import_typebox.Type.String({
+    minLength: 1,
+    description: "Installed Habitat command executed by the Codex hook."
+  }),
+  statusMessage: import_typebox.Type.String({
+    minLength: 1,
+    description: "Operator-facing status rendered while Habitat checks run."
+  }),
+  timeout: import_typebox.Type.Integer({
+    minimum: 1,
+    description: "Maximum seconds allowed for the Habitat hook command."
+  })
+}, { additionalProperties: false, description: "One Habitat-owned Codex hook command." });
+var HabitatOwnedHookGroupSchema = import_typebox.Type.Object({
+  _habitat: HabitatHookMarkerSchema,
+  hooks: import_typebox.Type.Array(HabitatHookCommandSchema, {
+    minItems: 1,
+    description: "Commands contributed by the installed Habitat package."
+  })
+}, { additionalProperties: false, description: "The named Habitat Codex hook contribution." });
+var CodexHooksSchema = import_typebox.Type.Object({
+  hooks: import_typebox.Type.Optional(import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.Array(HookGroupSchema), {
+    description: "Ordered hook groups keyed by Codex event identity."
+  }))
+}, { additionalProperties: true, description: "Consumer-owned Codex hook configuration." });
+var ConsumerPackageSchema = import_typebox.Type.Object({
+  trustedDependencies: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.String({ minLength: 1 }), {
+    description: "Package lifecycle scripts explicitly trusted by the Bun consumer."
+  }))
+}, { additionalProperties: true, description: "Nx consumer package metadata." });
+var hooksValidator = new import_schema.Validator({}, CodexHooksSchema);
+var packageValidator = new import_schema.Validator({}, ConsumerPackageSchema);
+function removeHabitatHook(tree, binding) {
+  const hooks = readHooks(tree);
+  const hookPlan = planHookRemoval(hooks, binding);
+  if (hookPlan.changed)
+    import_devkit.writeJson(tree, CODEX_HOOKS_PATH, hookPlan.value);
+}
+function readHooks(tree) {
+  if (!tree.exists(CODEX_HOOKS_PATH))
+    return { hooks: {} };
+  const input = import_devkit.readJson(tree, CODEX_HOOKS_PATH);
+  if (!hooksValidator.Check(input)) {
+    throw new Error(`${CODEX_HOOKS_PATH} is not a supported Codex hook document.`);
+  }
+  return input;
+}
+function planHookRemoval(hooks, binding) {
+  const location = oneOwnedHookLocation(hooks, binding);
+  if (location === undefined)
+    return { changed: false, value: hooks };
+  if (!import_node_util.isDeepStrictEqual(location.group, binding.hook) && !binding.predecessorHooks.some((predecessor) => import_node_util.isDeepStrictEqual(predecessor, location.group))) {
+    throw new Error(`${CODEX_HOOKS_PATH} contains an incompatible Habitat hook contribution.`);
+  }
+  const events = hooks.hooks ?? {};
+  const stop = events.Stop ?? [];
+  return {
+    changed: true,
+    value: {
+      ...hooks,
+      hooks: { ...events, Stop: stop.filter((_group, index) => index !== location.index) }
+    }
+  };
+}
+function oneOwnedHookLocation(hooks, binding) {
+  const identity = binding.hook._habitat.identity;
+  const locations = Object.entries(hooks.hooks ?? {}).flatMap(([event, groups]) => groups.flatMap((group, index) => {
+    const marked = group._habitat?.identity === identity;
+    const predecessor = binding.predecessorHooks.some((candidate) => import_node_util.isDeepStrictEqual(candidate, group));
+    return marked || predecessor ? [{ event, group, index }] : [];
+  }));
+  if (locations.length > 1) {
+    throw new Error(`${CODEX_HOOKS_PATH} contains multiple Habitat hook contributions.`);
+  }
+  const location = locations[0];
+  if (location !== undefined && location.event !== "Stop") {
+    throw new Error(`${CODEX_HOOKS_PATH} contains a Habitat hook contribution outside Stop.`);
+  }
+  return location;
+}
+
+// src/nx-generators.ts
+var habitatConsumerBinding = {
+  gritPackage: "@getgrit/cli",
+  nxPlugin: "@habitat-ai/cli/nx-plugin",
+  predecessorNxPlugins: [
+    {
+      plugin: "@habitat/cli/nx-plugin",
+      options: { checkTargetName: "check:policy" }
+    }
+  ],
+  hook: {
+    _habitat: { identity: "@habitat-ai/cli:agent-stop", revision: 1 },
+    hooks: [
+      {
+        type: "command",
+        command: 'bash -lc \'repo="${CODEX_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-}}"; if [ -n "$repo" ]; then repo="$(git -C "$repo" rev-parse --show-toplevel 2>/dev/null)"; else repo="$(git rev-parse --show-toplevel 2>/dev/null)"; fi && cd "$repo" 2>/dev/null || { printf "%s\\n" "Habitat agent-stop hook must run inside the repository worktree." >&2; exit 2; }; bunx --bun --no-install --package @habitat-ai/cli habitat hook agent-stop\'',
+        timeout: 120,
+        statusMessage: "Checking Habitat structure laws"
+      }
+    ]
+  },
+  predecessorHooks: [
+    {
+      hooks: [
+        {
+          type: "command",
+          command: 'bash -lc \'repo="${CODEX_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-}}"; if [ -n "$repo" ]; then repo="$(git -C "$repo" rev-parse --show-toplevel 2>/dev/null)"; else repo="$(git rev-parse --show-toplevel 2>/dev/null)"; fi && cd "$repo" 2>/dev/null || { printf "%s\\n" "Habitat agent-stop hook must run inside the repository worktree." >&2; exit 2; }; bun habitat hook agent-stop\'',
+          timeout: 120,
+          statusMessage: "Checking Habitat structure laws"
+        }
+      ]
+    }
+  ]
+};
+
+// src/generators/remove-hook.ts
+function removeHook(tree) {
+  removeHabitatHook(tree, habitatConsumerBinding);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,7 @@
+import { fileURLToPath } from "node:url";
+import { executeHabitat } from "./application.js";
+await executeHabitat({
+    appRoot: fileURLToPath(new URL("..", import.meta.url)),
+    development: true,
+    workspaceRoot: process.cwd(),
+});