holo-codex 0.1.0

package/plugins/autonomous-pr-loop/hooks/hooks.json

@@ -0,0 +1,106 @@
+{
+  "PreToolUse": [
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node ./hooks/dist/pre-tool-use.js",
+          "timeout": 1000,
+          "statusMessage": "Checking agent-loop command policy"
+        }
+      ]
+    }
+  ],
+  "PostToolUse": [
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node ./hooks/dist/post-tool-use.js",
+          "timeout": 500,
+          "statusMessage": "Recording agent-loop PostToolUse event"
+        }
+      ]
+    }
+  ],
+  "UserPromptSubmit": [
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node ./hooks/dist/user-prompt-submit.js",
+          "timeout": 500,
+          "statusMessage": "Recording agent-loop UserPromptSubmit event"
+        }
+      ]
+    }
+  ],
+  "Stop": [
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node ./hooks/dist/stop.js",
+          "timeout": 500,
+          "statusMessage": "Recording agent-loop Stop event"
+        }
+      ]
+    }
+  ],
+  "SessionStart": [
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node ./hooks/dist/session-start.js",
+          "timeout": 500,
+          "statusMessage": "Recording agent-loop SessionStart event"
+        }
+      ]
+    }
+  ],
+  "PreCompact": [
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node ./hooks/dist/pre-compact.js",
+          "timeout": 500,
+          "statusMessage": "Recording agent-loop PreCompact event"
+        }
+      ]
+    }
+  ],
+  "PostCompact": [
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node ./hooks/dist/post-compact.js",
+          "timeout": 500,
+          "statusMessage": "Recording agent-loop PostCompact event"
+        }
+      ]
+    }
+  ],
+  "PermissionRequest": [
+    {
+      "matcher": "*",
+      "hooks": [
+        {
+          "type": "command",
+          "command": "node ./hooks/dist/permission-request.js",
+          "timeout": 500,
+          "statusMessage": "Recording agent-loop PermissionRequest event"
+        }
+      ]
+    }
+  ]
+}

package/plugins/autonomous-pr-loop/hooks/observe-runner.ts

@@ -0,0 +1,25 @@
+import { readFileSync } from "node:fs";
+import { observeCodexHook } from "../core/hook-observer.js";
+import type { CodexHookEvent } from "../core/hook-events.js";
+
+export function runObserveOnlyHook(event: CodexHookEvent): void {
+  const input = readStdinJson();
+  const repoRoot = process.env.AGENT_LOOP_REPO_ROOT;
+  const result = observeCodexHook(event, input, repoRoot);
+  if (result.error) {
+    process.stderr.write(`agent-loop ${event} observe failed: ${result.error}\n`);
+  }
+  process.stdout.write(`${JSON.stringify({ continue: true })}\n`);
+}
+
+function readStdinJson(): unknown {
+  const text = readFileSync(0, "utf8");
+  if (text.trim().length === 0) {
+    return {};
+  }
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return { rawLength: text.length };
+  }
+}

package/plugins/autonomous-pr-loop/hooks/permission-request.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env tsx
+import { runObserveOnlyHook } from "./observe-runner.js";
+
+runObserveOnlyHook("PermissionRequest");

package/plugins/autonomous-pr-loop/hooks/post-compact.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env tsx
+import { runObserveOnlyHook } from "./observe-runner.js";
+
+runObserveOnlyHook("PostCompact");

package/plugins/autonomous-pr-loop/hooks/post-tool-use.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env tsx
+import { runObserveOnlyHook } from "./observe-runner.js";
+
+runObserveOnlyHook("PostToolUse");

package/plugins/autonomous-pr-loop/hooks/pre-compact.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env tsx
+import { runObserveOnlyHook } from "./observe-runner.js";
+
+runObserveOnlyHook("PreCompact");

package/plugins/autonomous-pr-loop/hooks/pre-tool-use.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env tsx
+import { readFileSync } from "node:fs";
+import { evaluatePreToolUseHook, toCodexHookResponse, type HookPolicyDecision } from "../core/hook-policy.js";
+
+const repoRoot = process.env.AGENT_LOOP_REPO_ROOT;
+const input = readStdinJson();
+const decision = safeEvaluate(input, repoRoot);
+process.stdout.write(`${JSON.stringify(toCodexHookResponse(decision))}\n`);
+
+function safeEvaluate(input: unknown, repoRoot: string | undefined): HookPolicyDecision {
+  try {
+    return evaluatePreToolUseHook(input, repoRoot);
+  } catch (error) {
+    return {
+      allow: false,
+      matchedPolicy: "hook_runner_error",
+      gate: "policy_violation",
+      blockedCommand: "<hook runner error>",
+      nextAction: "Run `agent-loop hooks doctor` and fix hook routing before retrying.",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+function readStdinJson(): unknown {
+  const text = readFileSync(0, "utf8");
+  if (text.trim().length === 0) {
+    return {};
+  }
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    const decision: HookPolicyDecision = {
+      allow: false,
+      matchedPolicy: "malformed_hook_payload",
+      gate: "policy_violation",
+      blockedCommand: "<unparseable hook payload>",
+      nextAction: "Retry the tool call with a valid PreToolUse payload.",
+      reason: "PreToolUse payload was not valid JSON."
+    };
+    process.stdout.write(`${JSON.stringify(toCodexHookResponse(decision))}\n`);
+    process.exit(0);
+  }
+}

package/plugins/autonomous-pr-loop/hooks/session-start.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env tsx
+import { runObserveOnlyHook } from "./observe-runner.js";
+
+runObserveOnlyHook("SessionStart");

package/plugins/autonomous-pr-loop/hooks/stop.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env tsx
+import { runObserveOnlyHook } from "./observe-runner.js";
+
+runObserveOnlyHook("Stop");

package/plugins/autonomous-pr-loop/hooks/user-prompt-submit.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env tsx
+import { runObserveOnlyHook } from "./observe-runner.js";
+
+runObserveOnlyHook("UserPromptSubmit");

package/plugins/autonomous-pr-loop/mcp-server/src/index.ts

@@ -0,0 +1,87 @@
+#!/usr/bin/env tsx
+import readline from "node:readline";
+import { resolveRepoRoot } from "../../core/repo-root.js";
+import { callMcpTool, MCP_TOOLS } from "./tools.js";
+
+interface JsonRpcRequest {
+  id?: string | number | null;
+  method?: string;
+  params?: unknown;
+}
+
+const repoRoot = resolveRepoRoot(process.env.AGENT_LOOP_REPO_ROOT ?? process.cwd());
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+let initialized = false;
+
+rl.on("line", (line) => {
+  void handleLine(line);
+});
+
+async function handleLine(line: string): Promise<void> {
+  if (line.trim().length === 0) {
+    return;
+  }
+  let request: JsonRpcRequest;
+  try {
+    request = JSON.parse(line) as JsonRpcRequest;
+  } catch (error) {
+    respond(null, undefined, errorPayload(-32700, "Parse error"));
+    return;
+  }
+
+  try {
+    if (request.method === "initialize") {
+      initialized = true;
+      respond(request.id, {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "autonomous-pr-loop", version: "0.1.0" }
+      });
+      return;
+    }
+    if (request.method === "ping") {
+      respond(request.id, {});
+      return;
+    }
+    if (!initialized) {
+      respond(request.id, undefined, errorPayload(-32002, "MCP server is not initialized."));
+      return;
+    }
+    if (request.method === "tools/list") {
+      respond(request.id, { tools: MCP_TOOLS });
+      return;
+    }
+    if (request.method === "tools/call") {
+      const params = isRecord(request.params) ? request.params : {};
+      const name = typeof params.name === "string" ? params.name : "";
+      const args = isRecord(params.arguments) ? params.arguments : {};
+      const result = await callMcpTool(name, args, repoRoot);
+      respond(request.id, {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      });
+      return;
+    }
+    if (request.id !== undefined) {
+      respond(request.id, undefined, errorPayload(-32601, `Method not found: ${request.method ?? ""}`));
+    }
+  } catch (error) {
+    respond(request.id, undefined, errorPayload(-32000, error instanceof Error ? error.message : String(error)));
+  }
+}
+
+function respond(id: JsonRpcRequest["id"], result?: unknown, error?: unknown): void {
+  process.stdout.write(`${JSON.stringify({
+    jsonrpc: "2.0",
+    id: id ?? null,
+    ...(error ? { error } : { result })
+  })}\n`);
+}
+
+function errorPayload(code: number, message: string): { code: number; message: string } {
+  return { code, message };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/plugins/autonomous-pr-loop/mcp-server/src/tools.ts

@@ -0,0 +1,205 @@
+import { createControllerHost } from "../../core/controller-host.js";
+import type { AgentTimelineSource, WorkerType } from "../../core/types.js";
+
+export interface McpToolDefinition {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: "object";
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+}
+
+const emptySchema = { type: "object" as const, properties: {} };
+
+export const MCP_TOOLS: McpToolDefinition[] = [
+  tool("loop_status", "Return current loop status.", emptySchema),
+  tool("loop_next_action", "Return the next recommended loop action.", emptySchema),
+  tool("loop_run_until_gate", "Start a background run until the next gate.", tokenSchema()),
+  tool("loop_resume", "Resume one loop step.", tokenSchema()),
+  tool("loop_stop", "Stop the current run.", tokenSchema()),
+  tool("loop_step", "Advance one loop step.", tokenSchema()),
+  tool("loop_list_gates", "List gates newest-first.", emptySchema),
+  tool("loop_explain_gate", "Explain one gate.", stringIdSchema("gateId")),
+  tool("loop_approve_gate", "Approve one gate with an operator note.", noteSchema("gateId")),
+  tool("loop_reject_gate", "Reject one gate with an operator note.", noteSchema("gateId")),
+  tool("loop_list_runs", "List persisted runs.", {
+    type: "object",
+    properties: { limit: { type: "number" } }
+  }),
+  tool("loop_agent_timeline", "List normalized agent timeline entries.", {
+    type: "object",
+    properties: {
+      cursor: { type: "string" },
+      limit: { type: "number" },
+      sources: {
+        type: "array",
+        items: { type: "string", enum: ["event", "worker_event", "worker", "state", "gate", "artifact", "decision"] }
+      },
+      runId: { type: "string" },
+      workerId: { type: "string" }
+    }
+  }),
+  tool("loop_read_artifact", "Read a persisted artifact by id.", stringIdSchema("artifactId")),
+  tool("loop_get_pr_status", "Return stored PR status for current run.", emptySchema),
+  tool("loop_get_ci_status", "Return stored CI checks for current run.", emptySchema),
+  tool("loop_get_review_comments", "Return stored review comments for current run.", emptySchema),
+  tool("loop_spawn_worker", "Spawn or dry-run a delegated worker.", {
+    type: "object",
+    required: ["type", "token"],
+    properties: {
+      type: { type: "string", enum: ["planner", "implementation", "review-fix", "ci-fix", "reviewer"] },
+      dryRun: { type: "boolean" },
+      token: { type: "string" }
+    }
+  }),
+  tool("loop_open_dashboard", "Return dashboard URL or unavailable status.", emptySchema)
+];
+
+/** Dispatch an MCP tool call to the shared controller. */
+export async function callMcpTool(name: string, args: Record<string, unknown>, repoRoot: string): Promise<unknown> {
+  const host = getControllerHost(repoRoot);
+  const controller = host.getController();
+  if (name === "loop_status") return controller.loopStatus();
+  if (name === "loop_next_action") return controller.loopNextAction();
+  if (name === "loop_run_until_gate") return controller.loopRunUntilGate(optionalString(args, "token"));
+  if (name === "loop_resume") return await controller.loopResume(optionalString(args, "token"));
+  if (name === "loop_stop") return controller.loopStop(optionalString(args, "token"));
+  if (name === "loop_step") return await controller.loopStep(optionalString(args, "token"));
+  if (name === "loop_list_gates") return controller.loopListGates();
+  if (name === "loop_explain_gate") return controller.loopExplainGate(requiredString(args, "gateId"));
+  if (name === "loop_approve_gate") return controller.loopApproveGate(requiredString(args, "gateId"), gateDecisionArgs(args), optionalString(args, "token"));
+  if (name === "loop_reject_gate") return controller.loopRejectGate(requiredString(args, "gateId"), gateDecisionArgs(args), optionalString(args, "token"));
+  if (name === "loop_list_runs") return controller.loopListRuns(optionalNumber(args, "limit"));
+  if (name === "loop_agent_timeline") return controller.loopAgentTimeline({
+    ...optionalStringObject(args, "cursor"),
+    ...optionalNumberObject(args, "limit"),
+    ...optionalStringObject(args, "runId"),
+    ...optionalStringObject(args, "workerId"),
+    ...optionalSourcesObject(args)
+  });
+  if (name === "loop_read_artifact") return controller.loopReadArtifact(requiredString(args, "artifactId"));
+  if (name === "loop_get_pr_status") return controller.loopGetPrStatus();
+  if (name === "loop_get_ci_status") return controller.loopGetCiStatus();
+  if (name === "loop_get_review_comments") return controller.loopGetReviewComments();
+  if (name === "loop_spawn_worker") return await controller.loopSpawnWorker(requiredWorkerType(args), optionalBoolean(args, "dryRun") ?? true, optionalString(args, "token"));
+  if (name === "loop_open_dashboard") return controller.loopOpenDashboard();
+  throw new Error(`Unknown tool: ${name}`);
+}
+
+const hosts = new Map<string, ReturnType<typeof createControllerHost>>();
+const MAX_HOSTS = 16;
+
+function getControllerHost(repoRoot: string): ReturnType<typeof createControllerHost> {
+  const existing = hosts.get(repoRoot);
+  if (existing) {
+    hosts.delete(repoRoot);
+    hosts.set(repoRoot, existing);
+    return existing;
+  }
+  if (hosts.size >= MAX_HOSTS) {
+    const oldestKey = hosts.keys().next().value as string | undefined;
+    if (oldestKey) {
+      hosts.get(oldestKey)?.dispose();
+      hosts.delete(oldestKey);
+    }
+  }
+  const host = createControllerHost({ repoRoot });
+  hosts.set(repoRoot, host);
+  return host;
+}
+
+function tool(name: string, description: string, inputSchema: McpToolDefinition["inputSchema"]): McpToolDefinition {
+  return { name, description, inputSchema };
+}
+
+function stringIdSchema(name: string): McpToolDefinition["inputSchema"] {
+  return {
+    type: "object",
+    required: [name],
+    properties: { [name]: { type: "string" } }
+  };
+}
+
+function noteSchema(idName: string): McpToolDefinition["inputSchema"] {
+  return {
+    type: "object",
+    required: [idName, "note", "token"],
+    properties: {
+      [idName]: { type: "string" },
+      note: { type: "string" },
+      source: { type: "string", enum: ["cli", "api", "ui", "nl"] },
+      payload: { type: "object" },
+      token: { type: "string" }
+    }
+  };
+}
+
+function tokenSchema(): McpToolDefinition["inputSchema"] {
+  return {
+    type: "object",
+    required: ["token"],
+    properties: { token: { type: "string" } }
+  };
+}
+
+function requiredString(args: Record<string, unknown>, name: string): string {
+  const value = args[name];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${name} is required`);
+  }
+  return value;
+}
+
+function optionalNumber(args: Record<string, unknown>, name: string): number | undefined {
+  const value = args[name];
+  return typeof value === "number" ? value : undefined;
+}
+
+function optionalNumberObject(args: Record<string, unknown>, name: string): Record<string, number> {
+  const value = optionalNumber(args, name);
+  return value === undefined ? {} : { [name]: value };
+}
+
+function optionalBoolean(args: Record<string, unknown>, name: string): boolean | undefined {
+  const value = args[name];
+  return typeof value === "boolean" ? value : undefined;
+}
+
+function optionalString(args: Record<string, unknown>, name: string): string | undefined {
+  const value = args[name];
+  return typeof value === "string" ? value : undefined;
+}
+
+function optionalStringObject(args: Record<string, unknown>, name: string): Record<string, string> {
+  const value = optionalString(args, name);
+  return value === undefined ? {} : { [name]: value };
+}
+
+function gateDecisionArgs(args: Record<string, unknown>): { note: string; source?: "cli" | "api" | "ui" | "nl"; payload?: Record<string, unknown> } {
+  const source = optionalString(args, "source");
+  const payload = args.payload;
+  return {
+    note: requiredString(args, "note"),
+    source: source === "cli" || source === "api" || source === "ui" || source === "nl" ? source : "nl",
+    payload: typeof payload === "object" && payload !== null && !Array.isArray(payload) ? payload as Record<string, unknown> : {}
+  };
+}
+
+function optionalSourcesObject(args: Record<string, unknown>): { sources?: AgentTimelineSource[] } {
+  const value = args.sources;
+  if (!Array.isArray(value)) {
+    return {};
+  }
+  const sources = value.filter((item): item is AgentTimelineSource => typeof item === "string");
+  return sources.length ? { sources } : {};
+}
+
+function requiredWorkerType(args: Record<string, unknown>): WorkerType {
+  const value = requiredString(args, "type");
+  if (["planner", "implementation", "review-fix", "ci-fix", "reviewer"].includes(value)) {
+    return value as WorkerType;
+  }
+  throw new Error(`Unsupported worker type: ${value}`);
+}

package/plugins/autonomous-pr-loop/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "autonomous-pr-loop",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=22.5"
+  }
+}

package/plugins/autonomous-pr-loop/schemas/config.schema.json

@@ -0,0 +1,74 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://holo-codex.local/schemas/config.schema.json",
+  "title": "AgentLoopConfig",
+  "type": "object",
+  "required": ["repoId"],
+  "additionalProperties": false,
+  "properties": {
+    "repoId": { "type": "string", "minLength": 1 },
+    "locale": { "enum": ["zh-CN", "en-US", "system"] },
+    "loopShape": { "enum": ["pr-loop", "generic-loop"] },
+    "workflowProfile": {
+      "enum": [
+        "default_pr_loop",
+        "docs_only_loop",
+        "review_fix_loop",
+        "release_ready_loop",
+        "research_report_loop",
+        "document_preparation_loop",
+        "repo_hygiene_loop",
+        "weekly_review_loop",
+        "data_extraction_loop"
+      ]
+    },
+    "roleProfile": { "enum": ["default_pr_roles"] },
+    "baseBranch": { "type": "string", "minLength": 1 },
+    "branchPrefix": { "type": "string", "minLength": 1 },
+    "plansDir": { "type": "string", "minLength": 1 },
+    "lintCommand": { "type": "string", "minLength": 1 },
+    "testCommand": { "type": "string", "minLength": 1 },
+    "gitnexusRepo": { "type": "string", "minLength": 1 },
+    "gitnexusRequired": { "type": "boolean" },
+    "requiredChecks": { "type": "array", "items": { "type": "string" } },
+    "requireReviewApproval": { "type": "boolean" },
+    "autonomyMode": {
+      "enum": ["supervised", "autonomous_until_gate", "autonomous_until_terminal"]
+    },
+    "mergeMode": {
+      "enum": ["manual", "conditional", "disabled"]
+    },
+    "notifyMode": {
+      "enum": ["all_gates", "important_only", "blockers_only"]
+    },
+    "reviewHandling": {
+      "enum": ["fix_scoped_and_carry_forward", "ask_on_any_review", "require_zero_open_findings"]
+    },
+    "carryoverTarget": { "type": "string", "minLength": 1 },
+    "allowAutoMerge": { "type": "boolean" },
+    "maxReviewFixRounds": { "type": "integer", "minimum": 0 },
+    "maxTestFixRounds": { "type": "integer", "minimum": 0 },
+    "maxCiReruns": { "type": "integer", "minimum": 0 },
+    "commandTimeoutMs": { "type": "integer", "minimum": 1 },
+    "commandOutputLimitBytes": { "type": "integer", "minimum": 1 },
+    "githubRetryMaxAttempts": { "type": "integer", "minimum": 1 },
+    "githubRetryBaseDelayMs": { "type": "integer", "minimum": 1 },
+    "reviewCiPollIntervalMs": { "type": "integer", "minimum": 1 },
+    "reviewCiMaxWaitMs": { "type": "integer", "minimum": 1 },
+    "workerBackend": { "enum": ["codex-exec", "codex-app-server"] },
+    "workerTimeoutMs": { "type": "integer", "minimum": 1 },
+    "workerMaxRetries": { "type": "integer", "minimum": 0 },
+    "workerEphemeral": { "type": "boolean" },
+    "protectedPaths": { "type": "array", "items": { "type": "string" } },
+    "dashboard": {
+      "type": "object",
+      "required": ["enabled", "host"],
+      "additionalProperties": false,
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "host": { "type": "string", "minLength": 1 },
+        "port": { "type": "integer", "minimum": 1, "maximum": 65535 }
+      }
+    }
+  }
+}

package/plugins/autonomous-pr-loop/schemas/marketplace.schema.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://holo-codex.local/schemas/marketplace.schema.json",
+  "title": "CodexRepoMarketplace",
+  "type": "object",
+  "required": ["name", "interface", "plugins"],
+  "additionalProperties": true,
+  "properties": {
+    "name": { "const": "codex-auto-pr-loop" },
+    "interface": {
+      "type": "object",
+      "required": ["displayName"],
+      "properties": {
+        "displayName": { "const": "HOLO-Codex" }
+      }
+    },
+    "plugins": {
+      "type": "array",
+      "minItems": 1,
+      "contains": {
+        "type": "object",
+        "required": ["name", "source", "policy", "category"],
+        "properties": {
+          "name": { "const": "autonomous-pr-loop" },
+          "source": {
+            "type": "object",
+            "required": ["source", "path"],
+            "properties": {
+              "source": { "const": "local" },
+              "path": { "const": "./plugins/autonomous-pr-loop" }
+            }
+          },
+          "policy": {
+            "type": "object",
+            "required": ["installation", "authentication"],
+            "properties": {
+              "installation": { "const": "AVAILABLE" },
+              "authentication": { "const": "ON_INSTALL" }
+            }
+          },
+          "category": { "const": "Engineering" }
+        }
+      }
+    }
+  }
+}

package/plugins/autonomous-pr-loop/schemas/plugin.schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://holo-codex.local/schemas/plugin.schema.json",
+  "title": "CodexPluginManifest",
+  "type": "object",
+  "required": ["name", "version", "description", "skills", "interface"],
+  "additionalProperties": true,
+  "properties": {
+    "name": { "const": "autonomous-pr-loop" },
+    "version": { "type": "string", "minLength": 1 },
+    "description": { "type": "string", "minLength": 1 },
+    "skills": { "const": "./skills/" },
+    "interface": {
+      "type": "object",
+      "required": ["displayName", "shortDescription", "category", "capabilities", "defaultPrompt"],
+      "additionalProperties": true,
+      "properties": {
+        "displayName": { "const": "HOLO-Codex" },
+        "shortDescription": { "type": "string", "minLength": 1 },
+        "category": { "const": "Engineering" },
+        "capabilities": {
+          "type": "array",
+          "contains": { "const": "Write" }
+        },
+        "defaultPrompt": {
+          "type": "array",
+          "contains": { "const": "进入 HOLO-Codex，继续跑到 gate" }
+        }
+      }
+    }
+  }
+}