ecoportal-api-graphql 1.3.5 → 1.3.9

data/.ai-assistance/scripts/lock-queue.sh

@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+# lock-queue.sh
+# Drop a priority turn-request into the bridge queue of one or more repos.
+# Used when a lock is held and this agent wants to wait with declared priority.
+#
+# Usage:
+#   bash lock-queue.sh \
+#     --agent cowork \
+#     --user oscar \
+#     --intent "Review auth changes" \
+#     --priority high \
+#     --target-project ep-claude-aws-platform \
+#     [--repo /path/to/repo1 --repo /path/to/repo2 ...] \
+#     [--expiry-minutes 90]
+#
+# Writes: .ai-assistance/bridge/queue/<priority>-<ts>-<id>.json in each repo
+# Exit 0: request(s) queued. Prints JSON with queue file paths.
+
+set -euo pipefail
+
+AGENT="" USER_SLUG="" INTENT="" PRIORITY="medium" TARGET_PROJECT=""
+EXPIRY_MINUTES=90 ESTIMATED_WAIT_MINUTES=""
+REPOS=()
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --agent)                AGENT="$2";                shift 2 ;;
+    --user)                 USER_SLUG="$2";            shift 2 ;;
+    --intent)               INTENT="$2";               shift 2 ;;
+    --priority)             PRIORITY="$2";             shift 2 ;;
+    --target-project)       TARGET_PROJECT="$2";       shift 2 ;;
+    --estimated-wait)       ESTIMATED_WAIT_MINUTES="$2"; shift 2 ;;
+    --repo)            REPOS+=("$2");       shift 2 ;;
+    --expiry-minutes)  EXPIRY_MINUTES="$2"; shift 2 ;;
+    *) echo "{\"queued\":false,\"reason\":\"unknown argument: $1\"}"; exit 1 ;;
+  esac
+done
+
+[[ -z "$AGENT" || -z "$USER_SLUG" || -z "$INTENT" ]] && {
+  echo '{"queued":false,"reason":"missing --agent, --user, or --intent"}'; exit 1; }
+
+# Default: current repo
+[[ ${#REPOS[@]} -eq 0 ]] && REPOS=("$(pwd)")
+
+NOW=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+EXPIRES=$(date -u -d "+${EXPIRY_MINUTES} minutes" +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null \
+       || date -u -v +${EXPIRY_MINUTES}M            +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null \
+       || echo "unknown")
+REQUEST_ID="req-$(date +%s)-$$"
+
+# Priority sort prefix: 1=critical 2=high 3=medium 4=low
+case "$PRIORITY" in
+  critical) PFX="1" ;; high) PFX="2" ;; medium) PFX="3" ;; low) PFX="4" ;; *) PFX="3" ;;
+esac
+
+QUEUED_FILES=()
+
+# estimated_wait: read from the current LOCK file if present (it may contain estimated_release)
+get_estimated_release() {
+  local lock="$1/.ai-assistance/bridge/LOCK"
+  [[ -f "$lock" ]] || { echo "unknown"; return; }
+  grep "estimated_release:" "$lock" 2>/dev/null | sed 's/.*estimated_release://' | tr -d ' ' | head -1 || echo "unknown"
+}
+
+for repo in "${REPOS[@]}"; do
+  QUEUE_DIR="$repo/.ai-assistance/bridge/queue"
+  [[ -d "$QUEUE_DIR" ]] || mkdir -p "$QUEUE_DIR"
+  QFILE="$QUEUE_DIR/${PFX}-${PRIORITY}-$(date +%s%3N)-${REQUEST_ID}.json"
+
+  # Read current lock's estimated release so queue entry shows the expected wait
+  LOCK_ESTIMATED_RELEASE=$(get_estimated_release "$repo")
+  EFFECTIVE_WAIT="${ESTIMATED_WAIT_MINUTES:-unknown}"
+
+  cat > "$QFILE" << JSON
+{
+  "request_id": "$REQUEST_ID",
+  "agent": "$AGENT",
+  "user": "$USER_SLUG",
+  "intent": "$INTENT",
+  "priority": "$PRIORITY",
+  "target_project": "$TARGET_PROJECT",
+  "repo": "$repo",
+  "requested_at": "$NOW",
+  "expires_at": "$EXPIRES",
+  "estimated_wait_minutes": "$EFFECTIVE_WAIT",
+  "current_lock_estimated_release": "$LOCK_ESTIMATED_RELEASE"
+}
+JSON
+  QUEUED_FILES+=("$QFILE")
+done
+
+# Report
+FILES_JSON=$(printf '"%s",' "${QUEUED_FILES[@]}" | sed 's/,$//')
+echo "{\"queued\":true,\"request_id\":\"$REQUEST_ID\",\"priority\":\"$PRIORITY\",\"files\":[$FILES_JSON]}"

data/.ai-assistance/scripts/setup-mcps.test.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env npx ts-node
+/**
+ * setup-mcps.test.ts
+ * Unit tests for the pure logic in setup-mcps.ts.
+ * No external dependencies — uses Node's assert module.
+ *
+ * Usage:
+ *   npx ts-node .ai-assistance/scripts/setup-mcps.test.ts
+ *
+ * Tests cover:
+ *   - parseEnvFile: key=value parsing, comments, blank lines, edge cases
+ *   - buildMcpEntries: correct shape for GitKraken + GitLab entries
+ *   - mergeConfig: merges, preserves unrelated keys, overwrites same-named entries
+ *   - getConfigPath: returns a string containing "Claude" on current platform
+ */
+
+import assert from "assert";
+import { parseEnvFile, buildMcpEntries, mergeConfig, getConfigPath } from "./setup-mcps";
+
+// ---------------------------------------------------------------------------
+// Test runner
+// ---------------------------------------------------------------------------
+
+let passed = 0;
+let failed = 0;
+
+function test(name: string, fn: () => void) {
+  try {
+    fn();
+    console.log(`  ✓ ${name}`);
+    passed++;
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(`  ✗ ${name}`);
+    console.log(`      ${message}`);
+    failed++;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// parseEnvFile
+// ---------------------------------------------------------------------------
+
+console.log("\nparseEnvFile");
+
+test("parses simple key=value pairs", () => {
+  const result = parseEnvFile("FOO=bar\nBAZ=qux");
+  assert.strictEqual(result["FOO"], "bar");
+  assert.strictEqual(result["BAZ"], "qux");
+});
+
+test("ignores comment lines", () => {
+  const result = parseEnvFile("# this is a comment\nFOO=bar");
+  assert.strictEqual(Object.keys(result).length, 1);
+  assert.strictEqual(result["FOO"], "bar");
+});
+
+test("ignores blank lines", () => {
+  const result = parseEnvFile("\n\nFOO=bar\n\n");
+  assert.strictEqual(Object.keys(result).length, 1);
+});
+
+test("handles values containing = signs", () => {
+  const result = parseEnvFile("URL=https://example.com?foo=bar");
+  assert.strictEqual(result["URL"], "https://example.com?foo=bar");
+});
+
+test("returns empty object for empty input", () => {
+  const result = parseEnvFile("");
+  assert.deepStrictEqual(result, {});
+});
+
+test("returns empty object for comment-only input", () => {
+  const result = parseEnvFile("# just a comment\n# another");
+  assert.deepStrictEqual(result, {});
+});
+
+// ---------------------------------------------------------------------------
+// buildMcpEntries
+// ---------------------------------------------------------------------------
+
+console.log("\nbuildMcpEntries");
+
+test("includes gitkraken entry with correct command", () => {
+  const entries = buildMcpEntries("tok", "https://gitlab.example.com");
+  const gk = entries["gitkraken"] as Record<string, unknown>;
+  assert.strictEqual(gk.command, "gk");
+  assert.deepStrictEqual(gk.args, ["mcp"]);
+});
+
+test("includes gitlab-mr entry with correct command", () => {
+  const entries = buildMcpEntries("tok", "https://gitlab.example.com");
+  const gl = entries["gitlab-mr"] as Record<string, unknown>;
+  assert.strictEqual(gl.command, "npx");
+  assert.deepStrictEqual(gl.args, ["-y", "@kopfrechner/gitlab-mr-mcp"]);
+});
+
+test("injects GITLAB_TOKEN into gitlab-mr env", () => {
+  const entries = buildMcpEntries("my-token", "https://gitlab.example.com");
+  const gl = entries["gitlab-mr"] as { env: Record<string, string> };
+  assert.strictEqual(gl.env["GITLAB_TOKEN"], "my-token");
+});
+
+test("injects GITLAB_URL into gitlab-mr env", () => {
+  const entries = buildMcpEntries("tok", "https://gitlab.example.com");
+  const gl = entries["gitlab-mr"] as { env: Record<string, string> };
+  assert.strictEqual(gl.env["GITLAB_URL"], "https://gitlab.example.com");
+});
+
+test("returns exactly two top-level keys", () => {
+  const entries = buildMcpEntries("tok", "https://gitlab.example.com");
+  assert.strictEqual(Object.keys(entries).length, 2);
+});
+
+// ---------------------------------------------------------------------------
+// mergeConfig
+// ---------------------------------------------------------------------------
+
+console.log("\nmergeConfig");
+
+test("adds mcpServers to empty config", () => {
+  const result = mergeConfig({}, { foo: { command: "foo" } });
+  assert.ok(result.mcpServers);
+  assert.ok((result.mcpServers as Record<string, unknown>)["foo"]);
+});
+
+test("preserves existing top-level keys", () => {
+  const result = mergeConfig({ theme: "dark" }, { foo: {} });
+  assert.strictEqual(result.theme, "dark");
+});
+
+test("preserves existing mcpServers entries not in newEntries", () => {
+  const existing = { mcpServers: { existing: { command: "old" } } };
+  const result = mergeConfig(existing, { newone: { command: "new" } });
+  const servers = result.mcpServers as Record<string, unknown>;
+  assert.ok(servers["existing"]);
+  assert.ok(servers["newone"]);
+});
+
+test("overwrites same-named mcpServers entries", () => {
+  const existing = {
+    mcpServers: { "gitlab-mr": { command: "old", env: { GITLAB_TOKEN: "old-tok" } } },
+  };
+  const result = mergeConfig(existing, {
+    "gitlab-mr": { command: "npx", env: { GITLAB_TOKEN: "new-tok" } },
+  });
+  const gl = (result.mcpServers as Record<string, unknown>)["gitlab-mr"] as {
+    env: Record<string, string>;
+  };
+  assert.strictEqual(gl.env["GITLAB_TOKEN"], "new-tok");
+});
+
+test("handles existing config with no mcpServers key", () => {
+  const result = mergeConfig({ theme: "light" }, { foo: {} });
+  assert.ok((result.mcpServers as Record<string, unknown>)["foo"]);
+  assert.strictEqual(result.theme, "light");
+});
+
+// ---------------------------------------------------------------------------
+// getConfigPath
+// ---------------------------------------------------------------------------
+
+console.log("\ngetConfigPath");
+
+test("returns a non-empty string", () => {
+  const p = getConfigPath();
+  assert.ok(typeof p === "string" && p.length > 0);
+});
+
+test("path contains 'Claude'", () => {
+  const p = getConfigPath();
+  assert.ok(p.includes("Claude"), `Expected path to contain 'Claude', got: ${p}`);
+});
+
+test("path ends with claude_desktop_config.json", () => {
+  const p = getConfigPath();
+  assert.ok(
+    p.endsWith("claude_desktop_config.json"),
+    `Expected path to end with filename, got: ${p}`
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Summary
+// ---------------------------------------------------------------------------
+
+console.log(`\n${passed + failed} tests: ${passed} passed, ${failed} failed\n`);
+if (failed > 0) process.exit(1);

data/.ai-assistance/scripts/setup-mcps.ts

@@ -0,0 +1,234 @@
+#!/usr/bin/env npx ts-node
+/**
+ * setup-mcps.ts
+ * One-time setup: writes GitKraken and GitLab MCP entries into Claude Desktop's
+ * global config (claude_desktop_config.json). Safe to re-run — merges into any
+ * existing config without overwriting unrelated entries.
+ *
+ * Usage:
+ *   npx ts-node .ai-assistance/scripts/setup-mcps.ts
+ *
+ * What it does:
+ *   1. Detects OS and locates claude_desktop_config.json
+ *   2. Reads GitLab credentials from .env as defaults (no re-entry needed)
+ *   3. Prompts to confirm or override each value
+ *   4. Backs up the existing config before writing
+ *   5. Merges GitKraken + GitLab MCP entries and writes the config
+ *   6. Prints verification steps
+ *
+ * Requirements:
+ *   - GitKraken CLI (gk) installed + authenticated:
+ *       https://www.gitkraken.com/cli
+ *       Run: gk auth login
+ *   - GitLab PAT with scopes: read_api, read_repository, create_runner, ai_features
+ *       https://gitlab.ecoportal.co.nz/-/user_settings/personal_access_tokens
+ *   - Node.js + ts-node:
+ *       npm install -g ts-node typescript
+ *
+ * Expiry note:
+ *   Current PAT expires April 2027. Token has rotation enabled — rotate before
+ *   expiry and re-run this script with the new token.
+ */
+
+import {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  copyFileSync,
+  mkdirSync,
+} from "fs";
+import { join, dirname } from "path";
+import { createInterface } from "readline";
+import { homedir, platform } from "os";
+
+// ---------------------------------------------------------------------------
+// Pure logic (exported for testing)
+// ---------------------------------------------------------------------------
+
+/** Detect OS-appropriate path to claude_desktop_config.json */
+export function getConfigPath(): string {
+  const p = platform();
+  if (p === "win32") {
+    const appData =
+      process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+    return join(appData, "Claude", "claude_desktop_config.json");
+  } else if (p === "darwin") {
+    return join(
+      homedir(),
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    );
+  } else {
+    // Linux fallback
+    return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+  }
+}
+
+/** Parse KEY=VALUE lines from a .env file. Ignores comments and blank lines. */
+export function parseEnvFile(content: string): Record<string, string> {
+  const env: Record<string, string> = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    const value = trimmed.slice(eq + 1).trim();
+    if (key) env[key] = value;
+  }
+  return env;
+}
+
+/** Build the mcpServers block for GitKraken + GitLab. */
+export function buildMcpEntries(
+  gitlabToken: string,
+  gitlabUrl: string
+): Record<string, unknown> {
+  return {
+    gitkraken: {
+      command: "gk",
+      args: ["mcp"],
+    },
+    "gitlab-mr": {
+      command: "npx",
+      args: ["-y", "@kopfrechner/gitlab-mr-mcp"],
+      env: {
+        GITLAB_TOKEN: gitlabToken,
+        GITLAB_URL: gitlabUrl,
+      },
+    },
+  };
+}
+
+/**
+ * Merge new MCP entries into an existing config object.
+ * Existing mcpServers entries not in newEntries are preserved.
+ * Entries in newEntries overwrite same-named existing entries.
+ */
+export function mergeConfig(
+  existing: Record<string, unknown>,
+  newEntries: Record<string, unknown>
+): Record<string, unknown> {
+  return {
+    ...existing,
+    mcpServers: {
+      ...((existing.mcpServers as Record<string, unknown>) ?? {}),
+      ...newEntries,
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// I/O helpers
+// ---------------------------------------------------------------------------
+
+function ask(question: string): Promise<string> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function loadEnvDefaults(repoRoot: string): Record<string, string> {
+  const envPath = join(repoRoot, ".env");
+  if (!existsSync(envPath)) return {};
+  return parseEnvFile(readFileSync(envPath, "utf8"));
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  // Resolve repo root relative to this script's location
+  const scriptDir = dirname(
+    process.argv[1]
+  );
+  const repoRoot = join(scriptDir, "../..");
+  const configPath = getConfigPath();
+  const env = loadEnvDefaults(repoRoot);
+
+  console.log("\n🔧 Claude Desktop MCP Setup");
+  console.log("============================");
+  console.log(`Config: ${configPath}\n`);
+
+  // Load existing config
+  let existing: Record<string, unknown> = {};
+  if (existsSync(configPath)) {
+    existing = JSON.parse(readFileSync(configPath, "utf8"));
+    const count = Object.keys(
+      (existing.mcpServers as Record<string, unknown>) ?? {}
+    ).length;
+    console.log(`Found existing config with ${count} MCP server(s) — will merge.\n`);
+  } else {
+    console.log("No existing config — will create fresh.\n");
+    mkdirSync(dirname(configPath), { recursive: true });
+  }
+
+  // --- GitLab PAT ---
+  const defaultToken = env["GITLAB_TOKEN"] ?? "";
+  const tokenHint = defaultToken
+    ? `from .env, ends …${defaultToken.slice(-6)}`
+    : "required";
+  const tokenInput = await ask(
+    `GitLab PAT [${tokenHint}] (press Enter to keep): `
+  );
+  const gitlabToken = tokenInput || defaultToken;
+
+  if (!gitlabToken) {
+    console.error(
+      "\n❌ GitLab PAT is required.\n" +
+        "   Create one at: https://gitlab.ecoportal.co.nz/-/user_settings/personal_access_tokens\n" +
+        "   Required scopes: read_api, read_repository, create_runner, ai_features\n" +
+        "   Enable token rotation. Current expiry: April 2027.\n"
+    );
+    process.exit(1);
+  }
+
+  // --- GitLab URL ---
+  const defaultUrl =
+    env["GITLAB_URL"] ?? "https://gitlab.ecoportal.co.nz";
+  const urlInput = await ask(`GitLab URL [${defaultUrl}]: `);
+  const gitlabUrl = urlInput || defaultUrl;
+
+  // --- Build + merge ---
+  const newEntries = buildMcpEntries(gitlabToken, gitlabUrl);
+  const merged = mergeConfig(existing, newEntries);
+
+  // --- Backup ---
+  if (existsSync(configPath)) {
+    const backupPath = configPath + ".backup";
+    copyFileSync(configPath, backupPath);
+    console.log(`\n✓ Backed up to ${backupPath}`);
+  }
+
+  // --- Write ---
+  writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+  console.log(`✓ Written to ${configPath}`);
+
+  console.log(`
+✅ Done! Next steps:
+
+  1. Restart Claude Desktop (fully quit and reopen)
+
+  2. Verify GitKraken — ask Claude:
+       "What branch am I on in ecoportal-api-graphql?"
+     First use opens a browser for GitKraken OAuth — approve it.
+
+  3. Verify GitLab — ask Claude:
+       "List open merge requests in ecoportal-api-graphql"
+
+  Note: if GitKraken (gk) isn't installed yet:
+    https://www.gitkraken.com/cli  →  gk auth login
+`);
+}
+
+main().catch((err) => {
+  console.error("\n❌ Setup failed:", err.message);
+  process.exit(1);
+});

data/.ai-assistance/scripts/task-complete.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env npx ts-node
+/**
+ * task-complete.ts
+ * Writes an outbox file and archives the inbox+outbox pair.
+ * Called by Code after finishing a bridge task.
+ *
+ * Usage:
+ *   npx ts-node .ai-assistance/scripts/task-complete.ts \
+ *     --task oscar-a3f2b1c-list-open-mrs.md \
+ *     --status done \
+ *     --result "Branch: feature/auth. Open MRs: 3 ..." \
+ *     --notes "GitLab plugin authenticated OK"
+ */
+
+import { writeFileSync, renameSync, readFileSync, mkdirSync, existsSync } from "fs";
+import { join, dirname } from "path";
+
+const args = process.argv.slice(2);
+const get = (flag: string, required = true): string | undefined => {
+  const i = args.indexOf(flag);
+  if (i === -1 || i + 1 >= args.length) {
+    if (required) { console.error(`Missing required argument: ${flag}`); process.exit(1); }
+    return undefined;
+  }
+  return args[i + 1];
+};
+
+const taskFile = get("--task")!;
+const status = (get("--status")! as string).toUpperCase(); // DONE or FAILED
+const result = get("--result")!;
+const notes = get("--notes", false) ?? "";
+
+const scriptDir = dirname(process.argv[1]);
+const bridgeDir = join(scriptDir, "../bridge");
+const inboxPath = join(bridgeDir, "inbox", taskFile);
+const outboxDir = join(bridgeDir, "outbox");
+const archiveDir = join(bridgeDir, "archive");
+
+if (!existsSync(inboxPath)) {
+  console.error(`Inbox task not found: ${inboxPath}`);
+  process.exit(1);
+}
+
+mkdirSync(outboxDir, { recursive: true });
+mkdirSync(archiveDir, { recursive: true });
+
+// Read title from inbox
+const inboxContent = readFileSync(inboxPath, "utf8");
+const titleMatch = inboxContent.match(/^# TASK: (.+)$/m);
+const title = titleMatch?.[1] ?? taskFile;
+
+// Write outbox
+const timestamp = new Date().toISOString();
+const outboxContent = `# TASK: ${title}
+STATUS: ${status}
+COMPLETED: ${timestamp}
+FROM: code
+TO: cowork
+
+## Result
+${result}
+
+## Notes
+${notes || "(none)"}
+`;
+
+const outboxPath = join(outboxDir, taskFile);
+writeFileSync(outboxPath, outboxContent, "utf8");
+
+// Archive both files
+renameSync(inboxPath, join(archiveDir, `inbox-${taskFile}`));
+renameSync(outboxPath, join(archiveDir, `outbox-${taskFile}`));
+
+console.log(JSON.stringify({ archived: taskFile, status, timestamp }));

data/.ai-assistance/scripts/task-create.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env npx ts-node
+/**
+ * task-create.ts
+ * Creates a new bridge inbox task file with correct naming and format.
+ * Keeps token usage low — agents call this instead of composing files manually.
+ *
+ * Usage:
+ *   npx ts-node .ai-assistance/scripts/task-create.ts \
+ *     --title "List open MRs" \
+ *     --request "Run git branch --show-current, then list open MRs via GitLab plugin" \
+ *     --expected "Branch name + MR table" \
+ *     --from cowork \
+ *     --to code \
+ *     --user oscar
+ */
+
+import { writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { randomUUID } from "crypto";
+
+// --- Parse args ---
+const args = process.argv.slice(2);
+const get = (flag: string): string => {
+  const i = args.indexOf(flag);
+  if (i === -1 || i + 1 >= args.length) {
+    console.error(`Missing required argument: ${flag}`);
+    process.exit(1);
+  }
+  return args[i + 1];
+};
+
+const title = get("--title");
+const request = get("--request");
+const expected = get("--expected");
+const from = get("--from");
+const to = get("--to");
+const user = get("--user");
+const context = args.includes("--context") ? get("--context") : "";
+
+// --- Generate filename ---
+const uuid7 = randomUUID().replace(/-/g, "").slice(0, 7);
+const slug = title
+  .toLowerCase()
+  .replace(/[^a-z0-9\s-]/g, "")
+  .trim()
+  .replace(/\s+/g, "-")
+  .slice(0, 40);
+const filename = `${user}-${uuid7}-${slug}.md`;
+
+// --- Build file content ---
+const timestamp = new Date().toISOString();
+const content = `# TASK: ${title}
+STATUS: PENDING
+CREATED: ${timestamp}
+FROM: ${from}
+TO: ${to}
+
+## Context
+${context || "(none provided)"}
+
+## Request
+${request}
+
+## Expected output
+${expected}
+`;
+
+// --- Write file ---
+const scriptDir = dirname(process.argv[1]);
+const inboxDir = join(scriptDir, "../bridge/inbox");
+mkdirSync(inboxDir, { recursive: true });
+const filePath = join(inboxDir, filename);
+writeFileSync(filePath, content, "utf8");
+
+console.log(JSON.stringify({ created: filename, path: filePath }));