summer-engine 2.8.2 → 3.0.0

package/dist/mcp/tools/with-engine.js

@@ -1,5 +1,10 @@
 import { getClient, resetClient } from "../server.js";
-import { recordMcpSession } from "../../lib/telemetry.js";
+import { recordMcpSession } from "../../core/telemetry.js";
+import { thrownErrorClass } from "../../core/tool-errors.js";
+import { extractOpError, getFailureReason, withOldEngineHint, } from "../../core/capabilities/engine-receipt.js";
+export { extractOpError, withOldEngineHint };
+export { missingEngineOpResult, } from "../../core/capability-skew.js";
+export { ToolInputError, UnsupportedOperationError } from "../../core/tool-errors.js";
 export const WITH_ENGINE_META = Symbol("summerWithEngineMeta");
 function attachMeta(result, meta) {
     Object.defineProperty(result, WITH_ENGINE_META, {
@@ -9,33 +14,6 @@ function attachMeta(result, meta) {
     });
     return result;
 }
-function getFailureReason(value) {
-    return typeof value.failureReason === "string"
-        ? value.failureReason
-        : typeof value.failure_reason === "string"
-            ? value.failure_reason
-            : undefined;
-}
-// 0.5.34 Block E contract (publicsummerengine src/lib/tools/contract.ts §0.1).
-// The async lifecycle (async-op-lifecycle.ts pollOpToTerminal) merges
-// terminalState/errorClass onto the apply dict it returns. ONLY these two are
-// "applied something / applied nothing-on-purpose" — every other terminal state
-// means the op did NOT land and must be surfaced as a failure, not masked.
-const SUCCESS_TERMINAL_STATES = new Set(["applied", "no_op"]);
-// Human-readable fallback when the engine reports a failure terminalState but no
-// `error` string (queue-full / lease-reject / identity-mismatch / no-progress
-// timeout frequently arrive with terminalState set and results[] absent).
-const TERMINAL_STATE_MESSAGES = {
-    timed_out: "Engine operation timed out. Its final state is unknown; inspect the target before retrying.",
-    still_queued: "Summer Engine accepted the operation, but it was still queued when the client stopped waiting. It may still run; do not retry blindly.",
-    still_running: "Summer Engine accepted and started the operation, but no final receipt arrived. It may still be running or may already have applied; inspect the target before retrying.",
-    uncertain: "Summer Engine did not provide a final operation receipt. The current state is uncertain; inspect the target before retrying.",
-    not_connected: "Summer Engine is not connected (terminalState: not_connected). Nothing was applied.",
-    identity_mismatch: "Operation rejected — wrong project/instance (terminalState: identity_mismatch). Nothing was mutated.",
-    content_mismatch: "Operation rejected — content changed since last read (terminalState: content_mismatch). Nothing was applied.",
-    denied: "Operation denied (terminalState: denied). Nothing was applied.",
-    canceled: "Operation canceled (terminalState: canceled). Nothing was applied.",
-};
 /** Pull the failure classifiers off an engine envelope for logging (best-effort,
  *  shape-tolerant). Does not decide success/failure — that stays in
  *  extractOpError. */
@@ -50,73 +28,6 @@ function readClassifiers(result) {
         failureReason: getFailureReason(op) ?? (failed ? getFailureReason(failed) : undefined),
     };
 }
-/**
- * Decide whether an engine result envelope represents a FAILURE, and if so
- * return a model-visible message. Returns null only for genuine success.
- *
- * Guards the two web bug classes (publicsummerengine cf17134f + contract.ts
- * `isFailureSignal`):
- *   - a failure `terminalState` (anything other than applied/no_op) is a failure
- *     even when results[] is absent — the cf17134f "no-results envelope looked
- *     applied" masking. The poll loop surfaces timed_out/etc. here.
- *   - an explicit ok:false / status:"error" / failed op inside results[].
- *
- * Exported for unit tests.
- */
-export function extractOpError(result) {
-    if (!result || typeof result !== "object")
-        return null;
-    const op = result;
-    const firstFailed = op.results?.find((r) => r.ok === false);
-    // The engine stamps failure classifiers on the envelope OR per-op inside
-    // results[] (the batch gate does the latter) — read both.
-    const failureReason = getFailureReason(op) ?? (firstFailed ? getFailureReason(firstFailed) : undefined);
-    // Classified failures are rendered as JSON so callers can reliably read
-    // failure_reason instead of scraping a sentence. A plain-text "Hint:" line may
-    // follow the JSON in the final tool text. Unclassified failures stay plain.
-    const classify = (message) => {
-        if (!failureReason)
-            return message;
-        return JSON.stringify({
-            error: message,
-            failure_reason: failureReason,
-            ...(typeof firstFailed?.error === "string" && firstFailed.error.length > 0 && firstFailed.error !== message
-                ? { op_error: firstFailed.error }
-                : {}),
-            ...(typeof firstFailed?.op === "string" ? { op: firstFailed.op } : {}),
-            ...(typeof op.terminalState === "string" ? { terminalState: op.terminalState } : {}),
-            ...(typeof op.errorClass === "string" ? { errorClass: op.errorClass } : {}),
-        }, null, 2);
-    };
-    // Failure terminalState takes precedence — it is set by the async lifecycle
-    // exactly when the op did not land (timeout, backpressure, lease/identity
-    // rejection, cancellation), sometimes with NO results[] to inspect. Prefer the
-    // precise engine rejection (envelope error, then the failed op's error) over
-    // the generic terminal-state sentence.
-    const ts = op.terminalState;
-    if (typeof ts === "string" && ts.length > 0 && !SUCCESS_TERMINAL_STATES.has(ts)) {
-        const message = (typeof op.error === "string" && op.error.length > 0 && op.error) ||
-            (typeof firstFailed?.error === "string" && firstFailed.error.length > 0 && firstFailed.error) ||
-            TERMINAL_STATE_MESSAGES[ts] ||
-            `Engine operation failed (terminalState: ${ts}).`;
-        return classify(message);
-    }
-    // An explicit ok:false / status:"error" / failed op inside results[] is a
-    // failure even when the engine omitted an error string — surface it rather
-    // than mask it (matches the web contract `isFailureSignal`). The envelope
-    // error is kept when present; the failed op's own error backs it up.
-    if (op.ok === false || op.status === "error" || firstFailed) {
-        const message = (typeof op.error === "string" && op.error.length > 0 && op.error) ||
-            (typeof firstFailed?.error === "string" && firstFailed.error.length > 0 && firstFailed.error) ||
-            (firstFailed
-                ? `Engine op failed${firstFailed.op ? ` (${firstFailed.op})` : ""}.`
-                : op.ok === false
-                    ? "Engine operation failed (ok: false)."
-                    : "Engine operation failed (status: error).");
-        return classify(message);
-    }
-    return null;
-}
 /**
  * An auth failure is the ONE class of thrown error that is provably pre-apply:
  * the engine rejects on the Bearer-token check (tool_net_thread.cpp::_validate_auth)
@@ -212,6 +123,18 @@ export async function withEngine(fn, opts) {
             return attachMeta({ content: [{ type: "text", text: JSON.stringify(result, null, 2) }] }, meta);
         }
         catch (err) {
+            // A tagged pre-apply throw (argument validation, or a client that cannot
+            // perform the op at all) never reached the engine: keep the cached
+            // client, skip the transport recovery recipe, and say so.
+            const preApply = thrownErrorClass(err);
+            if (preApply) {
+                return attachMeta(preApplyFailureResult(preApply, err), {
+                    errorClass: preApply,
+                    failureReason: PRE_APPLY_FAILURE_REASON[preApply],
+                    retried,
+                    boundProjectIdHash,
+                });
+            }
             // Drop the cached client (it may point at a dead/rotated engine). Retry
             // once only for a provably pre-apply auth failure; anything else surfaces.
             resetClient();
@@ -222,5 +145,46 @@ export async function withEngine(fn, opts) {
         }
     }
     const msg = lastError instanceof Error ? lastError.message : String(lastError);
-    return attachMeta({ content: [{ type: "text", text: msg }], isError: true }, { errorClass: "transport", retried, boundProjectIdHash });
+    return attachMeta({ content: [{ type: "text", text: withTransportRecovery(msg) }], isError: true }, { errorClass: "transport", retried, boundProjectIdHash });
+}
+const PRE_APPLY_FAILURE_REASON = {
+    input: "invalid_input",
+    unsupported: "unsupported_operation",
+};
+/** Model-visible result for a throw that is provably pre-apply. Rendered as
+ *  JSON like every other classified failure (callers read failure_reason
+ *  instead of scraping a sentence); `sent:false` is the load-bearing bit —
+ *  no mutation could have landed, so the model may fix the call and retry. */
+function preApplyFailureResult(errorClass, err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+        isError: true,
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    error: message,
+                    failure_reason: PRE_APPLY_FAILURE_REASON[errorClass],
+                    errorClass,
+                    sent: false,
+                    hint: errorClass === "input"
+                        ? "Nothing was sent to the engine. Fix the argument named in the error and call again — no inspection needed."
+                        : "Nothing was sent or applied. This client cannot perform the operation; use the alternative named in the error.",
+                }, null, 2),
+            }],
+    };
+}
+/** Every transport-level failure must TEACH recovery, not just name the error.
+ *  getClient()'s connect failure already carries its own instructions; anything
+ *  else (fetch failed / abort / HTTP status thrown mid-call) gets the generic
+ *  recovery recipe appended. Exported for unit tests. */
+export function withTransportRecovery(message) {
+    // Connect-path failures already prescribe (server.ts getClient appends the
+    // "Open the intended project…" instructions). Don't stack a second recipe.
+    if (message.includes("summer-engine run") || message.includes("summer-engine@latest run"))
+        return message;
+    return (message +
+        "\n\nRecovery: (1) check the engine is running and responsive — summer_get_project_context here, or `summer doctor` in a shell; " +
+        "(2) if this was a MUTATION, do NOT blind-retry — it may have partially applied; inspect the target first (summer_get_scene_tree / summer_world_snapshot / summer_read_file); " +
+        "(3) if the call was large or long-running, break it into smaller scripts/batches and re-run piece by piece; " +
+        "(4) if the engine restarted, the next tool call reconnects automatically — just retry a READ to confirm.");
 }

package/dist/project-memory/project-manifest.d.ts

@@ -0,0 +1,36 @@
+export declare const PROJECT_MANIFEST_RELPATH = ".summer/project.json";
+export type ProjectTemplateRecord = {
+    id: string;
+    version: string;
+    builtin: true;
+} | {
+    id: string;
+    version: string;
+    repo: string;
+    commit: string;
+    tree_digest: string;
+};
+export interface ProjectManifest {
+    template?: ProjectTemplateRecord;
+    toolkit_version?: string;
+    /** Summer Engine version seen at create time; absent when no engine was reachable. */
+    engine_version?: string;
+    created_at?: string;
+    [key: string]: unknown;
+}
+export declare function projectManifestPath(projectDir: string): string;
+export declare function readProjectManifest(projectDir: string): ProjectManifest | null;
+export interface ProjectManifestPatch {
+    template: ProjectTemplateRecord;
+    toolkit_version: string;
+    /** Recorded when given; an existing value survives a patch without one. */
+    engine_version?: string;
+    /** Override for tests; defaults to now. Only used when the file has no created_at yet. */
+    now?: () => Date;
+}
+/**
+ * Write (or merge into) `.summer/project.json`. Existing keys are preserved;
+ * `template` and `toolkit_version` (and `engine_version` when given) are
+ * replaced; `created_at` is set once.
+ */
+export declare function writeProjectManifest(projectDir: string, patch: ProjectManifestPatch): ProjectManifest;

package/dist/project-memory/project-manifest.js

@@ -0,0 +1,50 @@
+/**
+ * `.summer/project.json` — the project manifest (CONTRACT.md §8).
+ *
+ * Written by `summer create` so a fresh agent can answer "exactly which
+ * template, at which commit, built this project" without the original
+ * conversation. Merged, never clobbered: any other keys already in the file
+ * survive a rewrite.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+export const PROJECT_MANIFEST_RELPATH = ".summer/project.json";
+export function projectManifestPath(projectDir) {
+    return join(projectDir, PROJECT_MANIFEST_RELPATH);
+}
+export function readProjectManifest(projectDir) {
+    const file = projectManifestPath(projectDir);
+    if (!existsSync(file))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch (err) {
+        throw new Error(`${file} exists but is not valid JSON: ${err.message}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`${file} exists but is not a JSON object`);
+    }
+    return parsed;
+}
+/**
+ * Write (or merge into) `.summer/project.json`. Existing keys are preserved;
+ * `template` and `toolkit_version` (and `engine_version` when given) are
+ * replaced; `created_at` is set once.
+ */
+export function writeProjectManifest(projectDir, patch) {
+    const existing = readProjectManifest(projectDir) ?? {};
+    const now = patch.now ?? (() => new Date());
+    const manifest = {
+        ...existing,
+        template: patch.template,
+        toolkit_version: patch.toolkit_version,
+        ...(patch.engine_version ? { engine_version: patch.engine_version } : {}),
+        created_at: typeof existing.created_at === "string" ? existing.created_at : now().toISOString(),
+    };
+    const file = projectManifestPath(projectDir);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`, "utf-8");
+    return manifest;
+}

package/dist/project-memory/project-memory.d.ts

@@ -0,0 +1,57 @@
+import { type ProjectTemplateRecord } from "./project-manifest.js";
+export interface ProjectMemoryFileSummary {
+    path: string;
+    kind: string;
+    title: string | null;
+    modifiedTime: string;
+    bytes: number;
+    locked: boolean;
+}
+/**
+ * The template pin `summer create` records in `.summer/project.json`
+ * (CONTRACT.md §8): which template, at which commit, started this project,
+ * plus the toolkit (and, when known, engine) version that created it. It is
+ * project memory — the first fact a fresh agent needs — so it is surfaced
+ * next to GameSoul/build-plan instead of being a file nobody reads.
+ */
+export interface ProjectPinSummary {
+    /** Project-relative path of the manifest. */
+    path: string;
+    template: ProjectTemplateRecord | null;
+    toolkit_version: string | null;
+    engine_version: string | null;
+    created_at: string | null;
+}
+export interface ProjectMemorySummary {
+    present: boolean;
+    root: ".summer";
+    reason?: string;
+    /** `.summer/project.json`, or null when the project has no pin (created
+     *  outside `summer create`). */
+    pin: ProjectPinSummary | null;
+    /** Set when project.json exists but could not be read as a JSON object. */
+    pinError?: string;
+    canonical: {
+        gameSoul: ProjectMemoryFileSummary | null;
+        artBible: ProjectMemoryFileSummary | null;
+        audioBible: ProjectMemoryFileSummary | null;
+        buildPlan: ProjectMemoryFileSummary | null;
+        legacyVoiceCast: ProjectMemoryFileSummary | null;
+    };
+    structured: {
+        present: boolean;
+        indexPresent: boolean;
+        fileCount: number;
+        lockedCount: number;
+        files: ProjectMemoryFileSummary[];
+        truncated: boolean;
+    };
+    files: ProjectMemoryFileSummary[];
+    guidance: string;
+}
+export declare function getProjectMemorySummary(projectPath: string | null | undefined, options?: {
+    maxFiles?: number;
+}): ProjectMemorySummary;
+/** One line for status/doctor output: `template/<id>@<version>` (+ `builtin`
+ *  or the short commit), or null when the project has no pin. */
+export declare function formatProjectPin(pin: ProjectPinSummary | null): string | null;

package/dist/{lib → project-memory}/project-memory.js

@@ -1,5 +1,6 @@
 import { closeSync, existsSync, openSync, readSync, readdirSync, statSync, } from "node:fs";
 import { join, relative, sep } from "node:path";
+import { PROJECT_MANIFEST_RELPATH, readProjectManifest, } from "./project-manifest.js";
 const CANONICAL_FILES = [
     { key: "gameSoul", relativePath: ".summer/GameSoul.md", kind: "brief" },
     { key: "artBible", relativePath: ".summer/art-bible.md", kind: "art" },
@@ -33,9 +34,12 @@ export function getProjectMemorySummary(projectPath, options = {}) {
         ? scanMarkdownFiles(projectPath, memoryDir, maxFiles)
         : [];
     const indexPath = join(projectPath, ".summer", "memory", "index.json");
+    const { pin, pinError } = readProjectPin(projectPath);
     return {
         present: true,
         root: ".summer",
+        pin,
+        ...(pinError ? { pinError } : {}),
         canonical,
         structured: {
             present: existsSync(memoryDir),
@@ -49,10 +53,52 @@ export function getProjectMemorySummary(projectPath, options = {}) {
         guidance: "Read relevant .summer Markdown before creative, audio, dialogue, level, or character work. Ask before writing .summer files. Changing priority: locked memory requires explicit user confirmation.",
     };
 }
+/** The manifest as memory. A missing file is a null pin (not an error); an
+ *  unreadable one is reported, never thrown — a summary must not fail
+ *  because one file is corrupt. */
+function readProjectPin(projectPath) {
+    let manifest;
+    try {
+        manifest = readProjectManifest(projectPath);
+    }
+    catch (error) {
+        return {
+            pin: null,
+            pinError: error instanceof Error ? error.message : String(error),
+        };
+    }
+    if (!manifest)
+        return { pin: null };
+    const template = manifest.template;
+    const templateRecord = template && typeof template === "object" && typeof template.id === "string"
+        ? template
+        : null;
+    return {
+        pin: {
+            path: PROJECT_MANIFEST_RELPATH,
+            template: templateRecord,
+            toolkit_version: typeof manifest.toolkit_version === "string" ? manifest.toolkit_version : null,
+            engine_version: typeof manifest.engine_version === "string" ? manifest.engine_version : null,
+            created_at: typeof manifest.created_at === "string" ? manifest.created_at : null,
+        },
+    };
+}
+/** One line for status/doctor output: `template/<id>@<version>` (+ `builtin`
+ *  or the short commit), or null when the project has no pin. */
+export function formatProjectPin(pin) {
+    if (!pin)
+        return null;
+    if (!pin.template)
+        return `pin without template (${pin.path})`;
+    const template = pin.template;
+    const origin = "builtin" in template ? "builtin" : template.commit.slice(0, 12);
+    return `${template.id}@${template.version} (${origin})`;
+}
 function createEmptySummary() {
     return {
         present: false,
         root: ".summer",
+        pin: null,
         canonical: {
             gameSoul: null,
             artBible: null,

package/gemini-extension.json

@@ -1,12 +1,17 @@
 {
+  "_generated": "GENERATED from integrations/gemini — do not edit; npm run generate:registry",
   "name": "summer",
-  "version": "2.5.1",
+  "version": "3.0.0",
   "description": "Agent tooling for Summer Engine: MCP bridge, context primer, and game-dev skills. Use with the npm CLI for skill files on disk.",
   "contextFileName": "GEMINI.md",
   "mcpServers": {
     "summer-engine": {
       "command": "npx",
-      "args": ["summer-engine", "mcp"],
+      "args": [
+        "-y",
+        "summer-engine@latest",
+        "mcp"
+      ],
       "cwd": "${extensionPath}"
     }
   },
@@ -17,5 +22,101 @@
       "envVar": "SUMMER_PRE_COMMIT_DOCTOR",
       "sensitive": false
     }
+  ],
+  "skills": [
+    "./library/skills/3d-lighting/",
+    "./library/skills/adaptive-music/",
+    "./library/skills/agent-playtesting/",
+    "./library/skills/ambient-bed/",
+    "./library/skills/animated-loop/",
+    "./library/skills/animation-tree/",
+    "./library/skills/art-direction/",
+    "./library/skills/asset-strategy/",
+    "./library/skills/audio-direction/",
+    "./library/skills/auto-fire-targeting/",
+    "./library/skills/brainstorm-game/",
+    "./library/skills/brainstorming/",
+    "./library/skills/browse-templates/",
+    "./library/skills/celeste-momentum-platforming/",
+    "./library/skills/character-animation-wiring/",
+    "./library/skills/character-model/",
+    "./library/skills/character-portrait/",
+    "./library/skills/cinematic-cutscene/",
+    "./library/skills/concept-art/",
+    "./library/skills/create-asset-sheet/",
+    "./library/skills/debug/",
+    "./library/skills/debugging-game-feel/",
+    "./library/skills/design-level/",
+    "./library/skills/design-mechanic/",
+    "./library/skills/design-npc/",
+    "./library/skills/diagnosing-perf-regressions/",
+    "./library/skills/dispatching-parallel-agents/",
+    "./library/skills/driving-the-editor-ui/",
+    "./library/skills/environment-kit/",
+    "./library/skills/export-and-ship/",
+    "./library/skills/fabricating-assets/",
+    "./library/skills/facial-and-lipsync/",
+    "./library/skills/fps-controller/",
+    "./library/skills/game-feel/",
+    "./library/skills/gameskill/",
+    "./library/skills/gdscript-patterns/",
+    "./library/skills/generate-motion/",
+    "./library/skills/godogen-visual-proof-game-generation/",
+    "./library/skills/headless-scripting/",
+    "./library/skills/host-authoritative-state/",
+    "./library/skills/instantiate-asset-pack/",
+    "./library/skills/investigating-bugs/",
+    "./library/skills/lumera-single-image-scene-reconstruction/",
+    "./library/skills/make-game/",
+    "./library/skills/music-track/",
+    "./library/skills/navigate-summer/",
+    "./library/skills/new-project/",
+    "./library/skills/organic-model/",
+    "./library/skills/peer-to-peer-multiplayer/",
+    "./library/skills/pixel-art/",
+    "./library/skills/play/",
+    "./library/skills/playtesting-a-feature/",
+    "./library/skills/procedural-animation/",
+    "./library/skills/prop-model/",
+    "./library/skills/psx-retro-rendering/",
+    "./library/skills/realtime-wet-surfaces/",
+    "./library/skills/remote-deploy/",
+    "./library/skills/retarget/",
+    "./library/skills/running-in-the-cloud/",
+    "./library/skills/scene-composition/",
+    "./library/skills/scene-hierarchy-design/",
+    "./library/skills/scene-scripting/",
+    "./library/skills/scene-to-level/",
+    "./library/skills/setup-multiplayer/",
+    "./library/skills/skill-create/",
+    "./library/skills/skill-improve/",
+    "./library/skills/skill-test/",
+    "./library/skills/skintokens-auto-rigging/",
+    "./library/skills/skybox-panorama/",
+    "./library/skills/sound-effect/",
+    "./library/skills/spatial-placement/",
+    "./library/skills/sprite-sheet/",
+    "./library/skills/tileable-texture/",
+    "./library/skills/trailer-shot/",
+    "./library/skills/tune-performance/",
+    "./library/skills/ui-basics/",
+    "./library/skills/ui-graphics/",
+    "./library/skills/use-widget-asset/",
+    "./library/skills/using-summer/",
+    "./library/skills/vehicle-model/",
+    "./library/skills/verification-before-completion/",
+    "./library/skills/verifying-scenes/",
+    "./library/skills/vfx-dissolve/",
+    "./library/skills/vfx-fire/",
+    "./library/skills/vfx-hit-spark/",
+    "./library/skills/vfx-lightning/",
+    "./library/skills/vfx-magic-glow/",
+    "./library/skills/vfx-muzzle-flash/",
+    "./library/skills/vfx-smoke/",
+    "./library/skills/vfx-water-ripple/",
+    "./library/skills/voice-line/",
+    "./library/skills/world-building-3d/",
+    "./library/skills/writing-plans/",
+    "./library/skills/writing-skills/"
   ]
 }

package/hooks/hooks-cursor.json

@@ -9,9 +9,9 @@
         "timeout": 10
       }
     ],
-    "preToolUse": [
+    "beforeShellExecution": [
       {
-        "matcher": "Bash(git commit*)",
+        "matcher": "git\\s+commit",
         "command": "./hooks/run-hook.cmd pre-commit-doctor",
         "async": false,
         "timeout": 30

package/hooks/hooks.json

@@ -16,11 +16,12 @@
     ],
     "PreToolUse": [
       {
-        "matcher": "Bash(git commit*)",
+        "matcher": "Bash",
         "hooks": [
           {
             "type": "command",
             "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cmd\" pre-commit-doctor",
+            "if": "Bash(git commit*)",
             "async": false,
             "timeout": 30
           }