litcodex-ai 0.3.10 → 0.3.12

package/node_modules/@litcodex/lit-loop/dist/cli.js

@@ -14,7 +14,7 @@
 //
 // `main` NEVER calls process.exit (the shebang wrapper does); it resolves exactly one integer, so
 // the dispatcher is unit-testable with an injected argv array.
-import { runUserPromptSubmitHookCli } from "./hook-cli.js";
+import { runPreToolUseCreateGoalGuardCli, runUserPromptSubmitHookCli } from "./hook-cli.js";
 import { loopCommand } from "./loop-cli.js";
 const UNKNOWN_COMMAND = "lit-loop: unknown command\n";
 /**
@@ -25,11 +25,12 @@ export async function main(argv, stdin, stdout, stderr) {
     const command = argv[2];
     const subcommand = argv[3];
     if (command === "hook") {
-        if (subcommand !== "user-prompt-submit") {
-            stderr.write(UNKNOWN_COMMAND);
-            return 1;
-        }
-        return runUserPromptSubmitHookCli(stdin, stdout, stderr);
+        if (subcommand === "user-prompt-submit")
+            return runUserPromptSubmitHookCli(stdin, stdout, stderr);
+        if (subcommand === "pre-tool-use")
+            return runPreToolUseCreateGoalGuardCli(stdin, stdout, stderr);
+        stderr.write(UNKNOWN_COMMAND);
+        return 1;
     }
     if (command === "loop") {
         // T14: route to M09's loopCommand (argv past `loop`); it resolves one exit code (0/1/2/3/4/5)

package/node_modules/@litcodex/lit-loop/dist/codex-goal-instruction.js

@@ -25,6 +25,7 @@ function buildText(plan, goal, payload, isFinal) {
         "",
         "Codex goal integration constraints:",
         "- Use the create_goal payload exactly as rendered: objective only.",
+        "- LitCodex also installs a PreToolUse guard that denies create_goal calls carrying token_budget, status, metadata, or any non-objective key.",
         "- Goals are unlimited. Do not add numeric limits.",
         "- If get_goal/create_goal/update_goal are not exposed by this Codex session, continue with .litcodex/lit-loop durable state as the source of truth and record `native-goal-unavailable` in your handoff or ledger evidence; do not claim native /goal sync.",
         ...nativeGoalModeLines(mode),

package/node_modules/@litcodex/lit-loop/dist/codex-hook.d.ts

@@ -8,6 +8,11 @@ export interface LitUserPromptSubmitInput {
     readonly prompt: string;
     readonly transcript_path?: string | null;
 }
+export interface LitPreToolUseCreateGoalInput {
+    readonly hook_event_name: "PreToolUse";
+    readonly tool_name: "create_goal";
+    readonly tool_input: unknown;
+}
 /** Structured engine result. The CLI maps this to stdout / exit. */
 export type HookDecision = {
     readonly kind: "inject";
@@ -15,6 +20,12 @@ export type HookDecision = {
 } | {
     readonly kind: "noop";
 };
+export type PreToolUseCreateGoalDecision = {
+    readonly kind: "deny";
+    readonly stdout: string;
+} | {
+    readonly kind: "noop";
+};
 /**
  * Type-guard. True iff `value` is a record whose accepted event-name key (snake `hook_event_name`
  * primary, camel `hookEventName` fallback) === "UserPromptSubmit", `prompt` is a string, and the
@@ -22,12 +33,14 @@ export type HookDecision = {
  * accept-set, not a structural type assert, so a camelCase-keyed record also returns true.
  */
 export declare function isLitUserPromptSubmitInput(value: unknown): value is LitUserPromptSubmitInput;
+export declare function isLitPreToolUseCreateGoalInput(value: unknown): value is LitPreToolUseCreateGoalInput;
 /**
  * Wraps directive text in the Codex output envelope. Returns "" if the normalized context is empty
  * (caller treats "" as noop). Output is a single-line JSON + trailing "\n":
  * {"hookSpecificOutput":{"hookEventName":"UserPromptSubmit","additionalContext":<ctx>}}\n
  */
 export declare function formatAdditionalContextOutput(additionalContext: string): string;
+export declare function applyPreToolUseCreateGoalGuard(input: unknown): PreToolUseCreateGoalDecision;
 /**
  * Pure decision function (multi-mode router). Takes an already-parsed value (NOT a raw string).
  * Total over `unknown`; NEVER throws. Flow: validate shape → match the lit-family trigger token

package/node_modules/@litcodex/lit-loop/dist/codex-hook.js

@@ -22,6 +22,9 @@ import { shouldSuppressInjection } from "./guards.js";
 import { modeForToken } from "./modes.js";
 import { matchLitTrigger } from "./trigger.js";
 const HOOK_EVENT_NAME = "UserPromptSubmit";
+const PRE_TOOL_USE_EVENT_NAME = "PreToolUse";
+const CREATE_GOAL_TOOL_NAME = "create_goal";
+const CREATE_GOAL_DENY_REASON = "Use create_goal with objective only. Omit token_budget, status, metadata, and all other keys so the Codex goal stays unlimited; record native-goal-unavailable if the host goal tools are not available.";
 /** Narrow to a plain (non-null, non-array) record. */
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -64,6 +67,12 @@ export function isLitUserPromptSubmitInput(value) {
     }
     return isTranscriptPathValue(readTranscriptPath(value));
 }
+export function isLitPreToolUseCreateGoalInput(value) {
+    return (isRecord(value) &&
+        readEventName(value) === PRE_TOOL_USE_EVENT_NAME &&
+        value["tool_name"] === CREATE_GOAL_TOOL_NAME &&
+        Object.hasOwn(value, "tool_input"));
+}
 /**
  * Wraps directive text in the Codex output envelope. Returns "" if the normalized context is empty
  * (caller treats "" as noop). Output is a single-line JSON + trailing "\n":
@@ -82,6 +91,33 @@ export function formatAdditionalContextOutput(additionalContext) {
     };
     return `${JSON.stringify(output)}\n`;
 }
+function formatPreToolUseDenyOutput(reason) {
+    const output = {
+        hookSpecificOutput: {
+            hookEventName: PRE_TOOL_USE_EVENT_NAME,
+            permissionDecision: "deny",
+            permissionDecisionReason: reason,
+            additionalContext: reason,
+        },
+    };
+    return `${JSON.stringify(output)}\n`;
+}
+function hasObjectiveOnlyCreateGoalInput(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    return keys.length === 1 && keys[0] === "objective" && typeof value["objective"] === "string";
+}
+export function applyPreToolUseCreateGoalGuard(input) {
+    if (!isLitPreToolUseCreateGoalInput(input)) {
+        return { kind: "noop" };
+    }
+    if (hasObjectiveOnlyCreateGoalInput(input.tool_input)) {
+        return { kind: "noop" };
+    }
+    return { kind: "deny", stdout: formatPreToolUseDenyOutput(CREATE_GOAL_DENY_REASON) };
+}
 /**
  * Load the matched mode's directive behind a fail-silent boundary: any loader error (e.g. a missing
  * directives/<mode>.md or a marker-wrapper mismatch) resolves to "" so the hook degrades to a silent

package/node_modules/@litcodex/lit-loop/dist/hook-cli.d.ts

@@ -15,3 +15,4 @@ export type LitHookErrorCode = "LIT_HOOK_STDIN_INVALID_JSON" | "LIT_HOOK_STDIN_T
  * line to stderr on malformed / oversized stdin.
  */
 export declare function runUserPromptSubmitHookCli(stdin: NodeJS.ReadableStream, stdout: NodeJS.WritableStream, stderr: NodeJS.WritableStream): Promise<number>;
+export declare function runPreToolUseCreateGoalGuardCli(stdin: NodeJS.ReadableStream, stdout: NodeJS.WritableStream, stderr: NodeJS.WritableStream): Promise<number>;

package/node_modules/@litcodex/lit-loop/dist/hook-cli.js

@@ -6,7 +6,7 @@
 // valid event → 0 (no-op writes zero bytes); unparseable or oversized stdin → 2 with a
 // machine-readable LitHookError JSON line on stderr. NEVER calls process.exit (the dispatcher does)
 // and NEVER throws.
-import { runUserPromptSubmitHook } from "./codex-hook.js";
+import { applyPreToolUseCreateGoalGuard, runUserPromptSubmitHook } from "./codex-hook.js";
 /** Hard cap on stdin to bound memory / ReDoS exposure inside the 5 s Codex hook budget. 8 MB. */
 export const MAX_STDIN_BYTES = 8_000_000;
 const INVALID_JSON_MESSAGE = "lit hook: stdin was not valid JSON";
@@ -92,3 +92,30 @@ export async function runUserPromptSubmitHookCli(stdin, stdout, stderr) {
     }
     return 0;
 }
+export async function runPreToolUseCreateGoalGuardCli(stdin, stdout, stderr) {
+    const decoded = await readStdin(stdin);
+    if (decoded === null) {
+        stderr.write(errorLine("LIT_HOOK_STDIN_TOO_LARGE", TOO_LARGE_MESSAGE));
+        return 2;
+    }
+    let raw = decoded;
+    if (raw.charCodeAt(0) === 0xfeff) {
+        raw = raw.slice(1);
+    }
+    if (raw.trim().length === 0) {
+        return 0;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        stderr.write(errorLine("LIT_HOOK_STDIN_INVALID_JSON", INVALID_JSON_MESSAGE));
+        return 2;
+    }
+    const decision = applyPreToolUseCreateGoalGuard(parsed);
+    if (decision.kind === "deny") {
+        stdout.write(decision.stdout);
+    }
+    return 0;
+}

package/node_modules/@litcodex/lit-loop/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@litcodex/lit-loop",
-	"version": "0.3.10",
+	"version": "0.3.12",
 	"description": "LitCodex Lit-Loop runtime: durable repo-native multi-goal orchestration with embedded success criteria and observable evidence audit.",
 	"type": "module",
 	"bin": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "litcodex-ai",
-	"version": "0.3.10",
+	"version": "0.3.12",
 	"description": "Codex loop harness installer. Run `npx litcodex-ai install` to set up the LitCodex Codex platform: the bare `lit` hook and the durable lit-loop runtime.",
 	"keywords": ["codex", "litcodex", "lit-loop", "ai-agents", "orchestration"],
 	"author": "LitCodex Authors",
@@ -15,7 +15,7 @@
 	},
 	"files": ["bin", "dist", "model-catalog.json", "README.md", "LICENSE"],
 	"dependencies": {
-		"@litcodex/lit-loop": "0.3.10"
+		"@litcodex/lit-loop": "0.3.12"
 	},
 	"bundledDependencies": ["@litcodex/lit-loop"],
 	"scripts": {