@h-rig/runtime 0.0.6-alpha.0

package/dist/src/remote-http.js

@@ -0,0 +1,83 @@
+// @bun
+// packages/runtime/src/remote-http.ts
+function trimTrailingSlash(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function normalizeAuthToken(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function authHeaders(authToken) {
+  return authToken ? { authorization: `Bearer ${authToken}` } : {};
+}
+async function readJsonResponse(response, endpoint) {
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Rig runtime request failed for ${endpoint}: ${response.status} ${text}`.trim());
+  }
+  return await response.json();
+}
+async function postJson(fetchImpl, baseUrl, path, body, authToken) {
+  const endpoint = `${trimTrailingSlash(baseUrl)}${path}`;
+  const response = await fetchImpl(endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...authHeaders(authToken) },
+    body: JSON.stringify(body)
+  });
+  return readJsonResponse(response, endpoint);
+}
+
+class HttpRuntimeHostSession {
+  baseUrl;
+  fetchImpl;
+  authToken;
+  constructor(baseUrl, fetchImpl = fetch, options = {}) {
+    this.baseUrl = baseUrl;
+    this.fetchImpl = fetchImpl;
+    this.authToken = normalizeAuthToken(options.authToken ?? process.env.RIG_SERVER_AUTH_TOKEN ?? process.env.RIG_REMOTE_AUTH_TOKEN);
+  }
+  register(input) {
+    return postJson(this.fetchImpl, this.baseUrl, "/api/remote/hosts/register", input, this.authToken);
+  }
+  heartbeat(input) {
+    return postJson(this.fetchImpl, this.baseUrl, "/api/remote/hosts/heartbeat", input, this.authToken);
+  }
+  claimLease(input) {
+    return postJson(this.fetchImpl, this.baseUrl, "/api/remote/runs/claim", input, this.authToken);
+  }
+}
+
+class HttpRuntimeRunReporter {
+  baseUrl;
+  fetchImpl;
+  authToken;
+  constructor(baseUrl, fetchImpl = fetch, options = {}) {
+    this.baseUrl = baseUrl;
+    this.fetchImpl = fetchImpl;
+    this.authToken = normalizeAuthToken(options.authToken ?? process.env.RIG_SERVER_AUTH_TOKEN ?? process.env.RIG_REMOTE_AUTH_TOKEN);
+  }
+  reportStarted(input) {
+    return postJson(this.fetchImpl, this.baseUrl, "/api/remote/runs/start", input, this.authToken);
+  }
+  reportLog(input) {
+    return postJson(this.fetchImpl, this.baseUrl, "/api/remote/runs/log", input, this.authToken);
+  }
+  reportMessage(input) {
+    return postJson(this.fetchImpl, this.baseUrl, "/api/remote/runs/message", input, this.authToken);
+  }
+  reportCompleted(input) {
+    return postJson(this.fetchImpl, this.baseUrl, "/api/remote/runs/complete", input, this.authToken);
+  }
+  reportFailed(input) {
+    return postJson(this.fetchImpl, this.baseUrl, "/api/remote/runs/fail", input, this.authToken);
+  }
+  reportReleased(input) {
+    return postJson(this.fetchImpl, this.baseUrl, "/api/remote/runs/release", input, this.authToken);
+  }
+  reportArtifact(input) {
+    return postJson(this.fetchImpl, this.baseUrl, "/api/remote/runs/artifact", input, this.authToken);
+  }
+}
+export {
+  HttpRuntimeRunReporter,
+  HttpRuntimeHostSession
+};

package/dist/src/runtime-context.js

@@ -0,0 +1,216 @@
+// @bun
+// packages/runtime/src/control-plane/runtime/context.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+var RUNTIME_CONTEXT_ENV = "RIG_RUNTIME_CONTEXT_FILE";
+var DEFAULT_RUNTIME_MEMORY_RETRIEVAL = {
+  topK: 5,
+  lexicalWeight: 0.35,
+  vectorWeight: 0.45,
+  recencyWeight: 0.1,
+  confidenceWeight: 0.1
+};
+var runtimeContextStringFields = [
+  "runtimeId",
+  "taskId",
+  "role",
+  "workspaceDir",
+  "stateDir",
+  "logsDir",
+  "sessionDir",
+  "sessionFile",
+  "policyFile",
+  "binDir",
+  "createdAt"
+];
+var runtimeContextArrayFields = ["scopes", "validation"];
+var runtimeContextOptionalStringFields = [
+  "artifactRoot",
+  "hostProjectRoot",
+  "monorepoMainRoot",
+  "monorepoBaseRef",
+  "monorepoBaseCommit"
+];
+function writeRuntimeContext(path, ctx) {
+  const absPath = resolve(path);
+  const dir = dirname(absPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(absPath, JSON.stringify(ctx, null, 2), "utf8");
+}
+function loadRuntimeContext(path) {
+  const absPath = resolve(path);
+  if (!existsSync(absPath)) {
+    throw new Error(`RuntimeTaskContext file not found: ${absPath}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(absPath, "utf8"));
+  } catch (err) {
+    throw new Error(`Failed to parse RuntimeTaskContext at ${absPath}: ${String(err)}`);
+  }
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error(`RuntimeTaskContext at ${absPath} is not an object`);
+  }
+  const obj = raw;
+  for (const field of runtimeContextStringFields) {
+    if (typeof obj[field] !== "string" || obj[field].length === 0) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a non-empty string (at ${absPath})`);
+    }
+  }
+  for (const field of runtimeContextArrayFields) {
+    if (!Array.isArray(obj[field])) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be an array (at ${absPath})`);
+    }
+    if (!obj[field].every((entry) => typeof entry === "string")) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a string[] (at ${absPath})`);
+    }
+  }
+  for (const field of runtimeContextOptionalStringFields) {
+    if (field in obj && obj[field] !== undefined && typeof obj[field] !== "string") {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a string when present (at ${absPath})`);
+    }
+  }
+  if (obj.browser !== undefined) {
+    if (typeof obj.browser !== "object" || obj.browser === null || Array.isArray(obj.browser)) {
+      throw new Error(`RuntimeTaskContext field "browser" must be an object when present (at ${absPath})`);
+    }
+    const browser = obj.browser;
+    for (const field of [
+      "preset",
+      "mode",
+      "stateDir",
+      "defaultProfile",
+      "effectiveProfile",
+      "defaultAttachUrl",
+      "effectiveAttachUrl",
+      "launchHelper",
+      "checkHelper",
+      "attachInfoHelper",
+      "e2eHelper",
+      "resetProfileHelper"
+    ]) {
+      if (typeof browser[field] !== "string" || browser[field].length === 0) {
+        throw new Error(`RuntimeTaskContext field "browser.${field}" must be a non-empty string (at ${absPath})`);
+      }
+    }
+    for (const field of ["devCommand", "launchCommand", "checkCommand", "e2eCommand"]) {
+      if (browser[field] !== undefined && typeof browser[field] !== "string") {
+        throw new Error(`RuntimeTaskContext field "browser.${field}" must be a string when present (at ${absPath})`);
+      }
+    }
+    if (typeof browser.required !== "boolean") {
+      throw new Error(`RuntimeTaskContext field "browser.required" must be a boolean (at ${absPath})`);
+    }
+  }
+  if (obj.memory !== undefined) {
+    if (typeof obj.memory !== "object" || obj.memory === null || Array.isArray(obj.memory)) {
+      throw new Error(`RuntimeTaskContext field "memory" must be an object when present (at ${absPath})`);
+    }
+    const memory = obj.memory;
+    for (const field of ["canonicalPath", "canonicalRef", "canonicalBaseOid", "hydratedPath"]) {
+      if (typeof memory[field] !== "string" || memory[field].length === 0) {
+        throw new Error(`RuntimeTaskContext field "memory.${field}" must be a non-empty string (at ${absPath})`);
+      }
+    }
+    if (typeof memory.createdFresh !== "boolean") {
+      throw new Error(`RuntimeTaskContext field "memory.createdFresh" must be a boolean (at ${absPath})`);
+    }
+    if (typeof memory.retrieval !== "object" || memory.retrieval === null || Array.isArray(memory.retrieval)) {
+      throw new Error(`RuntimeTaskContext field "memory.retrieval" must be an object (at ${absPath})`);
+    }
+    const retrieval = memory.retrieval;
+    for (const field of ["topK", "lexicalWeight", "vectorWeight", "recencyWeight", "confidenceWeight"]) {
+      if (typeof retrieval[field] !== "number" || Number.isNaN(retrieval[field])) {
+        throw new Error(`RuntimeTaskContext field "memory.retrieval.${field}" must be a number (at ${absPath})`);
+      }
+    }
+  }
+  if (obj.initialDirtyFiles !== undefined) {
+    if (typeof obj.initialDirtyFiles !== "object" || obj.initialDirtyFiles === null || Array.isArray(obj.initialDirtyFiles)) {
+      throw new Error(`RuntimeTaskContext field "initialDirtyFiles" must be an object when present (at ${absPath})`);
+    }
+    const dirtyFiles = obj.initialDirtyFiles;
+    for (const key of ["project", "monorepo"]) {
+      if (dirtyFiles[key] === undefined) {
+        continue;
+      }
+      if (!Array.isArray(dirtyFiles[key]) || !dirtyFiles[key].every((entry) => typeof entry === "string")) {
+        throw new Error(`RuntimeTaskContext field "initialDirtyFiles.${key}" must be a string[] when present (at ${absPath})`);
+      }
+    }
+  }
+  if (obj.initialHeadCommits !== undefined) {
+    if (typeof obj.initialHeadCommits !== "object" || obj.initialHeadCommits === null || Array.isArray(obj.initialHeadCommits)) {
+      throw new Error(`RuntimeTaskContext field "initialHeadCommits" must be an object when present (at ${absPath})`);
+    }
+    const headCommits = obj.initialHeadCommits;
+    for (const key of ["project", "monorepo"]) {
+      if (headCommits[key] === undefined) {
+        continue;
+      }
+      if (typeof headCommits[key] !== "string") {
+        throw new Error(`RuntimeTaskContext field "initialHeadCommits.${key}" must be a string when present (at ${absPath})`);
+      }
+    }
+  }
+  return obj;
+}
+function runtimeMemoryEnvFromContext(ctx) {
+  if (!ctx?.memory) {
+    return {};
+  }
+  return {
+    RIG_MEMORY_DB_PATH: ctx.memory.hydratedPath,
+    RIG_MEMORY_CANONICAL_PATH: ctx.memory.canonicalPath,
+    RIG_MEMORY_CANONICAL_REF: ctx.memory.canonicalRef,
+    RIG_MEMORY_CANONICAL_BASE_OID: ctx.memory.canonicalBaseOid,
+    RIG_MEMORY_CREATED_FRESH: ctx.memory.createdFresh ? "1" : "0",
+    RIG_MEMORY_RETRIEVAL_TOP_K: String(ctx.memory.retrieval.topK),
+    RIG_MEMORY_RETRIEVAL_LEXICAL_WEIGHT: String(ctx.memory.retrieval.lexicalWeight),
+    RIG_MEMORY_RETRIEVAL_VECTOR_WEIGHT: String(ctx.memory.retrieval.vectorWeight),
+    RIG_MEMORY_RETRIEVAL_RECENCY_WEIGHT: String(ctx.memory.retrieval.recencyWeight),
+    RIG_MEMORY_RETRIEVAL_CONFIDENCE_WEIGHT: String(ctx.memory.retrieval.confidenceWeight)
+  };
+}
+function loadRuntimeContextFromEnv(env = process.env) {
+  const contextFile = env[RUNTIME_CONTEXT_ENV];
+  if (contextFile) {
+    return loadRuntimeContext(contextFile);
+  }
+  const inferred = findRuntimeContextFile(process.cwd());
+  if (!inferred) {
+    return null;
+  }
+  return loadRuntimeContext(inferred);
+}
+function findRuntimeContextFile(startPath) {
+  let current = resolve(startPath);
+  while (true) {
+    const candidate = resolve(current, "runtime-context.json");
+    if (existsSync(candidate) && isAgentRuntimeContextPath(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return "";
+    }
+    current = parent;
+  }
+}
+function isAgentRuntimeContextPath(path) {
+  const normalized = path.replace(/\\/g, "/");
+  return /\/\.rig\/runtime-context\.json$/.test(normalized);
+}
+export {
+  writeRuntimeContext,
+  runtimeMemoryEnvFromContext,
+  runtimeContextStringFields,
+  runtimeContextOptionalStringFields,
+  runtimeContextArrayFields,
+  loadRuntimeContextFromEnv,
+  loadRuntimeContext,
+  RUNTIME_CONTEXT_ENV,
+  DEFAULT_RUNTIME_MEMORY_RETRIEVAL
+};

package/dist/src/types.js

@@ -0,0 +1 @@
+// @bun

package/native/darwin-arm64/manifest.json

@@ -0,0 +1 @@
+{"platform":"darwin-arm64","suffix":"dylib","builtAt":"2026-06-07T22:55:24Z"}

package/native/linux-x64/manifest.json

@@ -0,0 +1 @@
+{"platform":"linux-x64","suffix":"so","builtAt":"2026-06-07T22:56:41Z"}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@h-rig/runtime",
+  "version": "0.0.6-alpha.0",
+  "type": "module",
+  "description": "Rig package",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "README.md",
+    "native",
+    "skills"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/src/index.js"
+    },
+    "./layout": {
+      "import": "./dist/src/layout.js"
+    },
+    "./local-server": {
+      "import": "./dist/src/local-server.js"
+    },
+    "./baked-secrets": {
+      "import": "./dist/src/baked-secrets.js"
+    },
+    "./binary-run": {
+      "import": "./dist/src/binary-run.js"
+    },
+    "./build-time-config": {
+      "import": "./dist/src/build-time-config.js"
+    },
+    "./control-plane/memory-sync": {
+      "import": "./dist/src/control-plane/memory-sync/index.js"
+    },
+    "./control-plane/repos": {
+      "import": "./dist/src/control-plane/repos/index.js"
+    },
+    "./control-plane/runtime": {
+      "import": "./dist/src/control-plane/runtime/index.js"
+    },
+    "./control-plane/runtime/image": {
+      "import": "./dist/src/control-plane/runtime/image/index.js"
+    },
+    "./control-plane/runtime/isolation": {
+      "import": "./dist/src/control-plane/runtime/isolation/index.js"
+    },
+    "./control-plane/runtime/snapshot": {
+      "import": "./dist/src/control-plane/runtime/snapshot/index.js"
+    },
+    "./control-plane/runtime/tooling": {
+      "import": "./dist/src/control-plane/runtime/tooling/index.js"
+    },
+    "./control-plane/state-sync": {
+      "import": "./dist/src/control-plane/state-sync/index.js"
+    },
+    "./control-plane/*": {
+      "import": "./dist/src/control-plane/*.js"
+    }
+  },
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "dependencies": {
+    "@libsql/client": "^0.17.2",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.0",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.0",
+    "@rig/hook-kit": "npm:@h-rig/hook-kit@0.0.6-alpha.0",
+    "@rig/shared": "npm:@h-rig/shared@0.0.6-alpha.0",
+    "@rig/validator-kit": "npm:@h-rig/validator-kit@0.0.6-alpha.0",
+    "effect": "4.0.0-beta.78"
+  }
+}

package/skills/rig-task-run.md

@@ -0,0 +1,71 @@
+---
+name: rig-task-run
+description: Rig task-run workflow contract — how an agent should execute a Rig-dispatched task end-to-end. Used by the server to brief the agent at run start.
+audience: agent
+---
+
+# Rig Task-Run Workflow
+
+Use the baked Rig runtime workflow only. Start by running `rig-agent info` and `rig-agent deps`. Use the baked agent binary via `$RIG_AGENT_BIN` for all Rig actions. Do not rely on bare `rig-agent` being on PATH.
+
+## Environment
+
+- `$RIG_TASK_WORKSPACE` and `$MONOREPO_ROOT` — absolute task worktree root.
+- `$PROJECT_RIG_ROOT` — outer control-plane repo root.
+- `$MONOREPO_MAIN_ROOT` — host monorepo checkout root (use only when you explicitly need the non-worktree path).
+- `$RIG_LOGS_DIR` / `$RIG_TASK_ID` — task validation logs land under `$RIG_LOGS_DIR/$RIG_TASK_ID/`.
+
+## Required first calls
+
+1. `"$RIG_AGENT_BIN" info` — confirm your assigned task, scope, validators.
+2. `"$RIG_AGENT_BIN" deps` — read decisions and next-actions from prior tasks.
+
+## Validation and completion
+
+- `"$RIG_AGENT_BIN" validate` — run validators for the task.
+- `"$RIG_AGENT_BIN" completion-verification` — final gate before finish.
+
+Before completion verification, scaffold and fill the required completion artifacts so the verifier has real inputs:
+
+1. `"$RIG_AGENT_BIN" artifacts` — write template files.
+2. Update `task-result.json`, `decision-log.md`, `next-actions.md`.
+3. Re-run `"$RIG_AGENT_BIN" artifacts` after real file edits to refresh `changed-files.txt`. Do not hand-edit runtime/control-plane paths into it.
+
+Make `decision-log.md` substantive: at least 3 distinct concrete lines covering what changed, why, and any downstream follow-up or risk. If you touch proto/OpenAPI/contract files, add `contract-changes.md` describing the contract impact before finishing.
+
+## Git flow
+
+After validation passes, use `"$RIG_AGENT_BIN" git status` or `"$RIG_AGENT_BIN" git preflight` to confirm branch state.
+
+To inspect or customize the PR before finish:
+
+- `"$RIG_AGENT_BIN" git commit --target monorepo`
+- `"$RIG_AGENT_BIN" git open-pr --target monorepo`
+
+Otherwise completion verification will auto-commit, open/refresh the PR, run Greptile review, and enable auto-merge when policy requires it.
+
+## AI review loop
+
+When AI review is required, **PR creation is not completion**. Treat `artifacts/<taskId>/review-status.txt`, `review-state.json`, and `review-feedback.md` as the source of truth.
+
+If Greptile returns `SKIP`, `REJECTED`, a timeout, unresolved comments, or any verdict other than `APPROVE`:
+
+1. Stay in the same runtime workspace.
+2. Resolve the concrete review feedback.
+3. Push the follow-up changes.
+4. Rerun `"$RIG_AGENT_BIN" completion-verification`.
+5. Repeat until `review-status.txt` is `APPROVED` and the review verdict is `APPROVE`.
+
+Do not commit or push artifact-only refreshes on review-loop retries. Only create a new commit when scoped task code, tests, configs, or generated contract outputs actually changed.
+
+Do not stop after opening the PR, after the first completion-verification run, or after an implementation-only success if review is still pending.
+
+## Validation failures
+
+If validation fails, inspect the generated task validation logs under `$RIG_LOGS_DIR/$RIG_TASK_ID/` and retry validation after fixing the concrete issue. Do not start searching unrelated workspace files for clues — the logs name the problem.
+
+## Conventions
+
+- Use `"$RIG_AGENT_BIN" git ...` commands for git status/commit/PR flow instead of raw git whenever possible.
+- Do not inspect or guess hidden control-plane script paths; use the baked Rig commands and files available in the runtime worktree.
+- Implement the task in the dedicated Rig runtime worktree, leave artifacts as needed, and finish through Rig's completion verification flow.