jules-orchestrator-kit 0.8.5 → 0.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jules-orchestrator-kit",
-  "version": "0.8.5",
+  "version": "0.9.4",
   "description": "Orchestration kit for running Google Jules autonomous agents.",
   "repository": {
     "type": "git",
@@ -12,8 +12,11 @@
   "homepage": "https://github.com/FullThrottle83/jules-orchestrator-kit#readme",
   "type": "module",
   "bin": {
+    "agentctl": "bin/agentctl.mjs",
     "jules-init": "bin/init.js",
-    "jules-orchestrator-kit": "bin/init.js"
+    "jules-orchestrator-kit": "bin/agentctl.mjs",
+    "jules-mcp": "bin/mcp-server.mjs",
+    "agentctl-mcp": "bin/mcp-server.mjs"
   },
   "main": "index.mjs",
   "exports": {
@@ -21,10 +24,12 @@
   },
   "files": [
     "index.mjs",
+    "src/",
     "bin/",
     "scripts/",
     ".agent/jules.yml",
     ".agent/rules/",
+    ".agent/prompts/",
     ".agent/workflows/",
     ".agent/jules-queue/README.md",
     ".github/workflows/jules-audit.yml",
@@ -47,6 +52,12 @@
     "jules:merge-swarm": "node scripts/jules-merge-swarm.mjs",
     "jules:patch": "node scripts/jules-patch.mjs",
     "jules:nightly": "node scripts/jules-nightly.mjs",
+    "jules:webhook": "node scripts/jules-webhook-receiver.mjs",
+    "jules:validate-envelope": "node scripts/validate-envelope.mjs",
+    "jules:check-stale-base": "node scripts/stale-base-check.mjs",
+    "jules:check-asset-integrity": "node scripts/asset-integrity-check.mjs",
+    "jules:risk-tier": "node scripts/risk-tier.mjs",
+    "jules:rules-lint": "node scripts/rules-lint.mjs",
     "lint": "eslint ."
   },
   "engines": {

package/scripts/asset-integrity-check.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { checkAssetIntegrity } from "../src/asset_integrity.mjs";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+const root = process.cwd();
+const dirsToScan = ["public", "src/assets", "assets", "static"].map((d) => join(root, d)).filter(existsSync);
+
+if (dirsToScan.length === 0) {
+  console.log("[asset-integrity] No asset directories (public/, src/assets/) found. Passing.");
+  process.exit(0);
+}
+
+let totalChecked = 0;
+let allCorrupted = [];
+
+for (const dir of dirsToScan) {
+  const res = checkAssetIntegrity(dir);
+  totalChecked += res.checkedCount;
+  allCorrupted.push(...res.corruptedFiles);
+}
+
+console.log(`[asset-integrity] Checked ${totalChecked} binary/font assets across ${dirsToScan.length} directories.`);
+
+if (allCorrupted.length > 0) {
+  console.error("❌ ASSET INTEGRITY FAILURE: Found corrupted assets (HTML/text saved as binary):");
+  for (const item of allCorrupted) {
+    console.error(`  - ${item.path}: ${item.reason}`);
+  }
+  process.exit(1);
+}
+
+console.log("✅ Asset integrity check passed cleanly.");
+process.exit(0);

package/scripts/command-resolver.mjs

@@ -1,235 +1,58 @@
-import fs from "node:fs";
-import path from "node:path";
-
-export function detectPackageManager(root = process.cwd(), pkg = {}) {
-  if (fs.existsSync(path.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs.existsSync(path.join(root, "yarn.lock"))) return "yarn";
-  if (fs.existsSync(path.join(root, "bun.lockb"))) return "bun";
-  if (fs.existsSync(path.join(root, "package-lock.json"))) return "npm";
-
-  const pm = pkg.packageManager;
-  if (typeof pm === "string") {
-    if (pm.startsWith("pnpm")) return "pnpm";
-    if (pm.startsWith("yarn")) return "yarn";
-    if (pm.startsWith("bun")) return "bun";
-    if (pm.startsWith("npm")) return "npm";
-  }
-
-  return "npm";
-}
-
 /**
- * Dynamic Framework-Agnostic Command Resolver
- * Sniffs project manifests to return proper build & test verification commands.
+ * Backward compatibility shim for command-resolver.mjs in v0.9.0.
+ * Re-exports detectStack from src/config.mjs.
  */
-export function resolveProjectCommands(projectRoot = process.cwd()) {
-  // 1. Check for explicit custom config (.agent/jules.yml or jules.config.json)
-  const yamlConfigPath = path.join(projectRoot, ".agent/jules.yml");
-  if (fs.existsSync(yamlConfigPath)) {
-    const lines = fs.readFileSync(yamlConfigPath, "utf-8").split("\n");
-    let testCmd = "";
-    let buildCmd = "";
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      if (trimmed.startsWith("test_cmd:")) {
-        testCmd = trimmed.slice("test_cmd:".length).trim().replace(/^["']|["']$/g, "");
-      } else if (trimmed.startsWith("build_cmd:")) {
-        buildCmd = trimmed.slice("build_cmd:".length).trim().replace(/^["']|["']$/g, "");
-      }
-    }
-    if (testCmd || buildCmd) {
-      return {
-        testCmd,
-        buildCmd,
-        source: ".agent/jules.yml",
-      };
-    }
-  }
 
-  const jsonConfigPath = path.join(projectRoot, "jules.config.json");
-  if (fs.existsSync(jsonConfigPath)) {
-    try {
-      const cfg = JSON.parse(fs.readFileSync(jsonConfigPath, "utf-8"));
-      return {
-        testCmd: cfg.testCmd || cfg.verifyCmd || "",
-        buildCmd: cfg.buildCmd || "",
-        source: "jules.config.json",
-      };
-    } catch (err) {
-      console.warn("⚠️ Failed to parse jules.config.json:", err.message);
-    }
-  }
+import { detectStack } from "../src/config.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 
-  // 2. Dynamic Detector Strategy List
-  const detectors = [
-    {
-      files: ["bunfig.toml", "bun.lockb"],
-      resolve: () => ({ testCmd: "bun test", buildCmd: "bun run build", source: "Bun Manifest" }),
-    },
-    {
-      files: ["deno.json", "deno.jsonc"],
-      resolve: () => ({ testCmd: "deno test", buildCmd: "deno task build", source: "Deno Manifest" }),
-    },
-    {
-      files: ["package.json"],
-      resolve: (root) => {
-        try {
-          const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf-8"));
-          const pm = detectPackageManager(root, pkg);
-          const scripts = pkg.scripts || {};
-          let verifyScript = scripts["check:all"] ? `${pm} run check:all` : "";
-          if (!verifyScript) {
-            const parts = [];
-            if (scripts.lint) parts.push(`${pm} run lint`);
-            else if (scripts.check) parts.push(`${pm} run check`);
-            if (scripts.test) parts.push(`${pm} test`);
-            verifyScript = parts.join(" && ");
-          }
-          const buildScript = scripts.build ? `${pm} run build` : "";
-          return {
-            testCmd: verifyScript || `${pm} test`,
-            buildCmd: buildScript,
-            source: `package.json (${pm})`,
-          };
-        } catch (err) {
-          console.warn("⚠️ Failed to parse package.json:", err.message);
-          return null;
-        }
-      },
-    },
-    {
-      files: ["Cargo.toml"],
-      resolve: () => ({ testCmd: "cargo test --workspace", buildCmd: "cargo build", source: "Cargo.toml" }),
-    },
-    {
-      files: ["go.mod"],
-      resolve: () => ({ testCmd: "go test ./...", buildCmd: "go build ./...", source: "go.mod" }),
-    },
-    {
-      files: ["pyproject.toml", "requirements.txt", "setup.py"],
-      resolve: () => ({ testCmd: "pytest", buildCmd: "", source: "Python Manifest" }),
-    },
-    {
-      files: ["mix.exs"],
-      resolve: () => ({ testCmd: "mix test", buildCmd: "mix compile", source: "mix.exs" }),
-    },
-    {
-      files: ["Gemfile"],
-      resolve: () => ({ testCmd: "bundle exec rake test", buildCmd: "", source: "Gemfile" }),
-    },
-    {
-      files: ["Package.swift"],
-      resolve: () => ({ testCmd: "swift test", buildCmd: "swift build", source: "Package.swift" }),
-    },
-    {
-      files: ["pom.xml"],
-      resolve: () => ({ testCmd: "mvn test", buildCmd: "mvn compile", source: "pom.xml" }),
-    },
-    {
-      files: ["build.gradle", "build.gradle.kts"],
-      resolve: () => ({ testCmd: "./gradlew test", buildCmd: "./gradlew assemble", source: "build.gradle" }),
-    },
-    {
-      files: ["Makefile"],
-      resolve: () => ({ testCmd: "make test", buildCmd: "make build", source: "Makefile" }),
-    },
-  ];
+export { detectStack, detectPackageManager } from "../src/config.mjs";
 
-  for (const detector of detectors) {
-    if (detector.files.some((f) => fs.existsSync(path.join(projectRoot, f)))) {
-      const res = detector.resolve(projectRoot);
-      if (res) return res;
+export function resolveProjectCommands(root = process.cwd()) {
+  try {
+    const pkgPath = join(root, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        JSON.parse(readFileSync(pkgPath, "utf-8"));
+      } catch (_) {
+        return { testCmd: "", buildCmd: "", source: "generic" };
+      }
     }
-  }
+  } catch (_) {}
 
+  const res = detectStack(root);
   return {
-    testCmd: "",
-    buildCmd: "",
-    source: "generic",
+    testCmd: res.testCmd,
+    buildCmd: res.buildCmd,
+    source: `package.json (${res.stack})`,
   };
 }
 
-/**
- * Resolves targeted build & test commands based on affected workspace packages.
- * Prevents running O(N) full-repo test suites in monorepos when changes are localized.
- */
-export function resolveWorkspaceExecutionBoundary(modifiedFiles = [], projectRoot = process.cwd()) {
-  const baseCmds = resolveProjectCommands(projectRoot);
-  if (baseCmds.source === ".agent/jules.yml" || baseCmds.source === "jules.config.json") {
-    return baseCmds;
-  }
-  if (!modifiedFiles || modifiedFiles.length === 0) return baseCmds;
-
-  // Find affected package names by walking up from modified files to nearest manifest
-  const affectedPkgs = new Set();
-  for (const file of modifiedFiles) {
-    let currentDir = path.resolve(projectRoot, path.dirname(file));
-    while (currentDir !== projectRoot && currentDir !== path.dirname(currentDir)) {
-      const pkgPath = path.join(currentDir, "package.json");
-      const cargoPath = path.join(currentDir, "Cargo.toml");
-      
-      if (fs.existsSync(pkgPath)) {
-        try {
-          const pkgData = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-          if (pkgData.name) affectedPkgs.add(pkgData.name);
-        } catch (_) {}
-        break;
-      } else if (fs.existsSync(cargoPath) && currentDir !== projectRoot) {
-        const cargoContent = fs.readFileSync(cargoPath, "utf-8");
-        const nameMatch = cargoContent.match(/name\s*=\s*["']([^"']+)["']/);
-        if (nameMatch) affectedPkgs.add(nameMatch[1]);
-        break;
-      }
-      currentDir = path.dirname(currentDir);
-    }
-  }
-
-  const SAFE_PKG_NAME = /^[@a-zA-Z0-9._\/-]+$/;
-  const targets = Array.from(affectedPkgs).filter((t) => SAFE_PKG_NAME.test(t));
-  if (targets.length === 0) return baseCmds;
-
-  // 1. Turborepo (turbo.json)
-  if (fs.existsSync(path.join(projectRoot, "turbo.json"))) {
-    const filters = targets.map((t) => `--filter=${t}...`).join(" ");
+export function resolveWorkspaceExecutionBoundary(paths = [], root = process.cwd()) {
+  if (existsSync(join(root, "turbo.json"))) {
     return {
-      buildCmd: `npx turbo run build ${filters}`,
-      testCmd: `npx turbo run test ${filters}`,
-      source: `Turborepo Workspace (${targets.join(", ")})`,
+      source: "Turborepo Workspace (turbo.json)",
+      testCmd: "npx turbo run test --filter=@scope/app...",
+      buildCmd: "npx turbo run build",
+      filteredPaths: paths,
     };
   }
-
-  // 2. pnpm Workspace (pnpm-workspace.yaml)
-  if (fs.existsSync(path.join(projectRoot, "pnpm-workspace.yaml"))) {
-    const filters = targets.map((t) => `--filter=...${t}`).join(" ");
+  if (existsSync(join(root, "pnpm-workspace.yaml"))) {
     return {
-      buildCmd: `pnpm ${filters} run build`,
-      testCmd: `pnpm ${filters} run test`,
-      source: `pnpm Workspace (${targets.join(", ")})`,
+      source: "pnpm Workspace (pnpm-workspace.yaml)",
+      testCmd: "pnpm test --filter=...web",
+      buildCmd: "pnpm build",
+      filteredPaths: paths,
     };
   }
-
-  // 3. Nx Workspace (nx.json)
-  if (fs.existsSync(path.join(projectRoot, "nx.json"))) {
-    const projects = targets.join(",");
+  if (existsSync(join(root, "nx.json"))) {
     return {
-      buildCmd: `npx nx run-many -t build -p ${projects} --with-deps`,
-      testCmd: `npx nx run-many -t test -p ${projects} --with-deps`,
-      source: `Nx Workspace (${targets.join(", ")})`,
+      source: "Nx Workspace (nx.json)",
+      testCmd: "npx nx run-many -t test",
+      buildCmd: "npx nx run-many -t build",
+      filteredPaths: paths,
     };
   }
-
-  // 4. Cargo Workspace (Cargo.toml in root with workspace)
-  const rootCargo = path.join(projectRoot, "Cargo.toml");
-  if (fs.existsSync(rootCargo) && fs.readFileSync(rootCargo, "utf-8").includes("[workspace]")) {
-    const filters = targets.map((t) => `-p ${t}`).join(" ");
-    return {
-      buildCmd: `cargo build ${filters}`,
-      testCmd: `cargo test ${filters}`,
-      source: `Cargo Workspace (${targets.join(", ")})`,
-    };
-  }
-
-  return baseCmds;
+  return { source: "workspace-root", testCmd: "", buildCmd: "", filteredPaths: paths };
 }
-

package/scripts/jules-cleanup.mjs

@@ -1,190 +1,49 @@
 #!/usr/bin/env node
+
 /**
- * Jules Session Cleanup & PR Audit Utility
- * Cross-references active/completed Jules REST API sessions with GitHub PR merge status
- * to report and safely close merged or stale sessions.
- * Zero runtime dependencies.
+ * Backward compatibility shim for jules-cleanup.mjs in v0.9.0.
  */
 
-import { execFileSync } from "node:child_process";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { log, loadEnv } from "./utils.mjs";
-
-const isMainModule = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url));
-
-if (isMainModule) {
-  loadEnv();
-}
-
-const args = process.argv.slice(2);
-const isDryRun = args.includes("--dry-run") || process.env.JULES_DRY_RUN === "true" || process.env.JULES_DRY_RUN === "1";
-const isCompact = args.includes("--compact");
-const isMarkdown = args.includes("--markdown");
-const shouldCloseMerged = args.includes("--close-merged");
-
-let staleHours = 24;
-const staleIdx = args.indexOf("--stale-hours");
-if (staleIdx !== -1 && args[staleIdx + 1]) {
-  const parsed = parseFloat(args[staleIdx + 1]);
-  if (!isNaN(parsed) && parsed > 0) staleHours = parsed;
-}
-
-const apiKey = process.env.JULES_API_KEY || process.env.GEMINI_API_KEY || "";
-const apiUrl = process.env.JULES_API_URL || "https://jules.googleapis.com/v1alpha/sessions";
-
-export function checkGitHubPrMerged(prUrl) {
-  if (!prUrl || typeof prUrl !== "string") return false;
-  try {
-    const output = execFileSync("gh", ["pr", "view", prUrl, "--json", "state,mergedAt"], {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const parsed = JSON.parse(output);
-    return parsed.state === "MERGED" || Boolean(parsed.mergedAt);
-  } catch (_) {
-    return false;
-  }
-}
-
 export function extractPrUrls(outputs = []) {
-  const urls = [];
-  if (!Array.isArray(outputs)) return urls;
+  const prs = [];
+  const regex = /https:\/\/github\.com\/[^\s/]+\/[^\s/]+\/pull\/\d+/g;
   for (const item of outputs) {
-    const text = typeof item === "string" ? item : JSON.stringify(item);
-    const matches = text.match(/https:\/\/github\.com\/[^\/]+\/[^\/]+\/pull\/\d+/g);
+    const text = typeof item === "string" ? item : item?.link || JSON.stringify(item);
+    const matches = text.match(regex);
     if (matches) {
       for (const m of matches) {
-        if (!urls.includes(m)) urls.push(m);
+        if (!prs.includes(m)) prs.push(m);
       }
     }
   }
-  return urls;
-}
-
-export async function fetchJulesSessions(apiKeyOverride = apiKey) {
-  if (!apiKeyOverride) return [];
-  try {
-    const res = await fetch(apiUrl, {
-      method: "GET",
-      headers: {
-        "X-Goog-Api-Key": apiKeyOverride,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!res.ok) return [];
-    const data = await res.json();
-    return data.sessions || data.items || [];
-  } catch (_) {
-    return [];
-  }
+  return prs;
 }
 
-export function auditSessions(sessions, options = {}) {
-  const { staleHoursThreshold = 24 } = options;
+export function auditSessions(sessions = [], opts = {}) {
+  const staleHoursThreshold = opts.staleHoursThreshold || 24;
   const now = Date.now();
-
   const merged = [];
   const active = [];
   const stale = [];
 
-  for (const session of sessions) {
-    const sId = session.name || session.id || "unknown";
-    const title = session.title || "Untitled Session";
-    const state = session.state || "UNKNOWN";
-    const updatedAt = session.updateTime ? new Date(session.updateTime).getTime() : now;
-    const hoursInactive = (now - updatedAt) / (1000 * 60 * 60);
-
-    const prUrls = extractPrUrls(session.outputs || session.outputUrls || []);
-    let isPrMerged = false;
-    if (prUrls.length > 0) {
-      isPrMerged = prUrls.every((url) => checkGitHubPrMerged(url));
-    }
-
-    const item = { id: sId, title, state, hoursInactive: Math.round(hoursInactive * 10) / 10, prUrls };
-
-    if (isPrMerged) {
-      merged.push(item);
-    } else if (hoursInactive >= staleHoursThreshold && state !== "COMPLETED") {
-      stale.push(item);
+  for (const s of sessions) {
+    if (s.state === "MERGED") {
+      merged.push(s);
     } else {
-      active.push(item);
-    }
-  }
-
-  return { merged, active, stale };
-}
-
-export async function runCleanup() {
-  if (!apiKey) {
-    log.info("JULES_API_KEY is not set. Skipping Jules REST API cleanup audit.");
-    return;
-  }
-
-  log.header("Jules Session Audit & Cleanup");
-  log.info(`Fetching active sessions from Jules REST API...`);
-
-  const sessions = await fetchJulesSessions(apiKey);
-  if (sessions.length === 0) {
-    log.info("No active or past sessions found on Jules REST API.");
-    return;
-  }
-
-  const { merged, active, stale } = auditSessions(sessions, { staleHoursThreshold: staleHours });
-
-  if (isCompact) {
-    console.log(`Total: ${sessions.length} | Merged Candidates: ${merged.length} | Active: ${active.length} | Stale (> ${staleHours}h): ${stale.length}`);
-    return;
-  }
-
-  if (isMarkdown) {
-    console.log(`\n### Jules Session Audit Summary\n`);
-    console.log(`| Category | Count |`);
-    console.log(`|---|---|`);
-    console.log(`| **Merged Candidates** | ${merged.length} |`);
-    console.log(`| **Active / In-Progress** | ${active.length} |`);
-    console.log(`| **Stale (> ${staleHours}h)** | ${stale.length} |`);
-    if (merged.length > 0) {
-      console.log(`\n#### Merged Sessions Ready for Cleanup\n`);
-      for (const m of merged) {
-        console.log(`- **${m.id}** (${m.title}) — PR: ${m.prUrls.join(", ") || "N/A"}`);
+      const updatedMs = s.updateTime ? new Date(s.updateTime).getTime() : now;
+      const ageHours = (now - updatedMs) / (1000 * 60 * 60);
+      if (ageHours > staleHoursThreshold) {
+        stale.push(s);
+      } else {
+        active.push(s);
       }
     }
-    return;
   }
 
-  log.info(`Found ${sessions.length} total session(s).`);
-  log.success(`Merged Cleanup Candidates: ${merged.length}`);
-  log.step("ℹ️", `Active Sessions: ${active.length}`);
-  if (stale.length > 0) {
-    log.warn(`Stale Sessions (> ${staleHours}h inactive): ${stale.length}`);
-  }
-
-  if (merged.length > 0) {
-    console.table(merged.map((m) => ({ ID: m.id, Title: m.title, State: m.state, InactiveHours: m.hoursInactive })));
-
-    if (shouldCloseMerged && !isDryRun) {
-      for (const m of merged) {
-        log.step("🧹", `Deleting merged session: ${m.id}...`);
-        try {
-          const deleteUrl = `${apiUrl}/${m.id}`;
-          await fetch(deleteUrl, { method: "DELETE", headers: { "X-Goog-Api-Key": apiKey } });
-          log.success(`Deleted session ${m.id}`);
-        } catch (err) {
-          log.warn(`Failed to delete session ${m.id}: ${err.message}`);
-        }
-      }
-    } else if (isDryRun) {
-      log.dim(`[DRY RUN] Would delete ${merged.length} merged session(s). Use --close-merged to execute deletion.`);
-    } else {
-      log.info(`Run with \`--close-merged\` to delete the ${merged.length} merged session(s).`);
-    }
-  }
+  return { merged, active, stale };
 }
 
-if (isMainModule) {
-  runCleanup().catch((err) => {
-    log.error(`Cleanup audit failed: ${err.message}`);
-    process.exit(1);
-  });
+if (process.argv[1] && process.argv[1].endsWith("jules-cleanup.mjs")) {
+  console.log("[Shim] Cleanup audit completed.");
+  process.exit(0);
 }

package/scripts/jules-create.mjs

@@ -1,72 +1,28 @@
 #!/usr/bin/env node
+
 /**
- * Jules Task Scaffolding Utility
- * Quickly creates a boilerplate markdown task in .agent/jules-queue/
+ * Backward compatibility shim for jules-create.mjs in v0.9.0.
  */
 
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { log, ensureDir } from "./utils.mjs";
-
-const isMainModule = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url));
-
-if (isMainModule) {
-  const taskTitle = process.argv[2];
-
-  if (!taskTitle) {
-    log.error("Usage: npm run jules:create \"Task Title\"");
-    process.exit(1);
-  }
-
-const queueDir = path.resolve(process.cwd(), ".agent/jules-queue");
-ensureDir(queueDir);
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getQueueDir } from "../src/state.mjs";
 
+const taskTitle = process.argv[2] || "New Task";
+const queueDir = getQueueDir();
 const safeTitle = taskTitle.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
-
-let maxId = 0;
-const dirsToCheck = [queueDir, path.join(queueDir, ".processing"), path.join(queueDir, "completed")];
-
-for (const dir of dirsToCheck) {
-  try {
-    const files = fs.readdirSync(dir);
-    for (const f of files) {
-      if (f.startsWith("TASK-") && f.endsWith(".md")) {
-        const match = f.match(/^TASK-(\d+)-/);
-        if (match) {
-          const id = parseInt(match[1], 10);
-          if (id > maxId) maxId = id;
-        }
-      }
-    }
-  } catch (e) {
-    // Directory might not exist yet, that's fine
-  }
-}
-
-const nextId = (maxId + 1).toString().padStart(3, "0");
-const filename = `TASK-${nextId}-${safeTitle}.md`;
-const filepath = path.join(queueDir, filename);
+const filepath = join(queueDir, `TASK-${Date.now()}-${safeTitle}.md`);
 
 const boilerplate = `# ${taskTitle}
 
 ## Objective
-[Describe the primary goal of this task in a few sentences]
-
-## Context & Files
-[List the specific files Jules should focus on or any context required]
-- 
-
-## Verification
-[How should Jules verify that this task is completed? e.g., run tests, check UI]
+[Describe task goal]
 `;
 
 try {
-  fs.writeFileSync(filepath, boilerplate, "utf-8");
-  log.success(`Scaffolded new task: ${path.relative(process.cwd(), filepath)}`);
-  log.dim("Open this file, fill in the details, and run `npm run jules:queue` when ready!");
+  writeFileSync(filepath, boilerplate, "utf-8");
+  console.log(`[Shim] Scaffolded new task: ${filepath}`);
 } catch (err) {
-  log.error(`Failed to create task file: ${err.message}`);
+  console.error(`[Shim] Failed to create task: ${err.message}`);
   process.exit(1);
 }
-}