patchrelay 0.36.5 → 0.36.7

package/README.md

@@ -161,6 +161,8 @@ PatchRelay uses repo-local workflow files as prompts for Codex runs:
 
 These files define how the agent should work in that repository. Keep them short, action-oriented, and human-authored.
 
+The built-in PatchRelay prompt scaffold lives in `src/prompting/patchrelay.ts`. It is intentionally small: task objective, scope discipline, reactive repair context, workflow guidance, and publication contract. Installation-level and repo-level prompt config can add one extra instructions file or replace a small set of policy sections. See [`docs/prompting.md`](./docs/prompting.md).
+
 ## Knowledge And Validation Surfaces
 
 PatchRelay works best when repository guidance follows progressive disclosure:
@@ -306,6 +308,7 @@ Useful commands:
 - `patchrelay issue path APP-123 --cd`
 - `patchrelay issue open APP-123`
 - `patchrelay issue retry APP-123`
+- `patchrelay service restart`
 - `patchrelay service logs --lines 100`
 
 PatchRelay's operator surface is being reduced to its own runtime responsibilities: issue status,

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.36.5",
-  "commit": "1f30d4407cf6",
-  "builtAt": "2026-04-09T08:27:55.606Z"
+  "version": "0.36.7",
+  "commit": "93dd74dadf6f",
+  "builtAt": "2026-04-09T11:23:49.821Z"
 }

package/dist/cli/cluster-health.js

@@ -44,13 +44,13 @@ export async function collectClusterHealth(config, db, runCommand) {
         ? await probeOptionalService(runCommand, "review-quill", {
             healthy: (payload) => {
                 const parsed = payload;
-                return parsed.health?.ok === true && parsed.systemd?.ActiveState === "active";
+                return parsed.health?.reachable === true && parsed.health?.ok === true && parsed.systemd?.ActiveState === "active";
             },
             summarize: (payload) => {
                 const parsed = payload;
-                return parsed.health?.ok === true
-                    ? `Healthy (${typeof parsed.watch?.runningAttempts === "number" ? `${parsed.watch.runningAttempts} running attempts` : "service reachable"})`
-                    : `Unhealthy (${parsed.healthError ?? "service health unavailable"})`;
+                return parsed.health?.reachable === true && parsed.health?.ok === true
+                    ? "Healthy"
+                    : `Unhealthy (${parsed.health?.reachable === false ? "service not reachable" : "service health unavailable"})`;
             },
         })
         : undefined;
@@ -68,13 +68,13 @@ export async function collectClusterHealth(config, db, runCommand) {
         ? await probeOptionalService(runCommand, "merge-steward", {
             healthy: (payload) => {
                 const parsed = payload;
-                return parsed.systemd?.ActiveState === "active";
+                return parsed.health?.reachable === true && parsed.health?.ok === true && parsed.systemd?.ActiveState === "active";
             },
             summarize: (payload) => {
                 const parsed = payload;
-                return parsed.systemd?.ActiveState === "active"
+                return parsed.health?.reachable === true && parsed.health?.ok === true && parsed.systemd?.ActiveState === "active"
                     ? "Healthy"
-                    : `Unhealthy (${parsed.systemd?.ActiveState ?? "unknown"})`;
+                    : `Unhealthy (${parsed.health?.reachable === false ? "service not reachable" : parsed.systemd?.ActiveState ?? "unknown"})`;
             },
         })
         : undefined;

package/dist/cli/commands/setup.js

@@ -1,11 +1,11 @@
-import { getDefaultConfigPath, getDefaultRuntimeEnvPath, getDefaultServiceEnvPath, getSystemdUnitPath, } from "../../runtime-paths.js";
+import { getSystemdUnitPath, } from "../../runtime-paths.js";
 import { initializePatchRelayHome, installServiceUnits } from "../../install.js";
 import { loadConfig } from "../../config.js";
 import { parsePositiveIntegerFlag } from "../args.js";
 import { CliUsageError } from "../errors.js";
 import { formatJson } from "../formatters/json.js";
 import { writeOutput } from "../output.js";
-import { installServiceCommands, restartServiceCommands, runServiceCommands, tryManageService } from "../service-commands.js";
+import { installServiceCommands, runServiceCommands, runSystemctl, tryManageService } from "../service-commands.js";
 export async function handleInitCommand(params) {
     try {
         const requestedPublicBaseUrl = typeof params.parsed.flags.get("public-base-url") === "string"
@@ -113,24 +113,25 @@ export async function handleInstallServiceCommand(params) {
     }
 }
 export async function handleRestartServiceCommand(params) {
-    try {
-        await runServiceCommands(params.runCommand, restartServiceCommands());
-        writeOutput(params.stdout, params.json
-            ? formatJson({
-                service: "patchrelay",
-                unitPath: getSystemdUnitPath(),
-                runtimeEnvPath: getDefaultRuntimeEnvPath(),
-                serviceEnvPath: getDefaultServiceEnvPath(),
-                configPath: getDefaultConfigPath(),
-                restarted: true,
-            })
-            : "Reloaded systemd units and reload-or-restart was requested for PatchRelay.\n");
-        return 0;
-    }
-    catch (error) {
-        writeOutput(params.stderr, `${error instanceof Error ? error.message : String(error)}\n`);
-        return 1;
-    }
+    const daemonReload = await runSystemctl(params.runCommand, ["daemon-reload"]);
+    const restart = await runSystemctl(params.runCommand, ["reload-or-restart", "patchrelay.service"]);
+    const ok = daemonReload.ok && restart.ok;
+    writeOutput(ok ? params.stdout : params.stderr, params.json
+        ? formatJson({
+            service: "patchrelay",
+            unit: "patchrelay.service",
+            daemonReloaded: daemonReload.ok,
+            restarted: restart.ok,
+            errors: [
+                ...(daemonReload.ok ? [] : [daemonReload.error]),
+                ...(restart.ok ? [] : [restart.error]),
+            ],
+        })
+        : [
+            daemonReload.ok ? "systemd daemon-reload completed." : `systemd daemon-reload failed: ${daemonReload.error}`,
+            restart.ok ? "Restarted patchrelay.service" : `Restart failed: ${restart.error}`,
+        ].join("\n") + "\n");
+    return ok ? 0 : 1;
 }
 function parseSystemctlShowOutput(raw) {
     const properties = {};
@@ -148,23 +149,28 @@ function parseSystemctlShowOutput(raw) {
 async function readPatchRelayHealth() {
     try {
         const config = loadConfig(undefined, { profile: "doctor" });
-        const response = await fetch(`http://${config.server.bind}:${config.server.port}${config.server.healthPath}`, { signal: AbortSignal.timeout(2000) });
-        let body;
+        const host = config.server.bind === "0.0.0.0" ? "127.0.0.1" : config.server.bind;
+        const response = await fetch(`http://${host}:${config.server.port}${config.server.healthPath}`, { signal: AbortSignal.timeout(2000) });
+        let ok = response.ok;
         try {
-            body = await response.json();
+            const body = await response.json();
+            if (typeof body.ok === "boolean") {
+                ok = response.ok && body.ok;
+            }
         }
         catch {
-            body = undefined;
+            ok = response.ok;
         }
         return {
             reachable: true,
+            ok,
             status: response.status,
-            ...(body ? { body } : {}),
         };
     }
     catch (error) {
         return {
             reachable: false,
+            ok: false,
             error: error instanceof Error ? error.message : String(error),
         };
     }
@@ -201,7 +207,6 @@ export async function handleServiceCommand(params) {
         const payload = {
             service: "patchrelay",
             unit: "patchrelay.service",
-            unitPath: getSystemdUnitPath(),
             systemd: properties,
             health,
         };
@@ -217,7 +222,7 @@ export async function handleServiceCommand(params) {
                 `Unit path: ${properties.FragmentPath || getSystemdUnitPath()}`,
                 properties.ExecMainPID ? `Main PID: ${properties.ExecMainPID}` : undefined,
                 health.reachable
-                    ? `Health: reachable (HTTP ${health.status})${typeof health.body?.version === "string" ? ` version ${health.body.version}` : ""}`
+                    ? `Health: ${health.ok ? "ok" : "unhealthy"} (HTTP ${health.status})`
                     : `Health: not reachable (${health.error})`,
             ]
                 .filter(Boolean)

package/dist/cli/help.js

@@ -165,7 +165,7 @@ export function serviceHelpText() {
         "Commands:",
         "  install [--force] [--write-only] [--json]  Reinstall the systemd service unit",
         "  restart [--json]                           Reload-or-restart the service",
-        "  status [--json]                            Show systemd state and service health",
+        "  status [--json]                            Show systemd state and local health",
         "  logs [--lines <count>] [--json]            Show recent journal logs",
         "",
         "Examples:",

package/dist/cli/service-commands.js

@@ -23,6 +23,17 @@ export async function tryManageService(runner, commands) {
         return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
+export async function runSystemctl(runner, args) {
+    const result = await runner("sudo", ["systemctl", ...args]);
+    if (result.exitCode === 0) {
+        return { ok: true, result };
+    }
+    return {
+        ok: false,
+        error: `Command failed with exit code ${result.exitCode}: sudo systemctl ${args.join(" ")}${summarizeCommandOutput(result)}`,
+        result,
+    };
+}
 export function installServiceCommands() {
     return [
         { command: "sudo", args: ["systemctl", "daemon-reload"] },

package/dist/config.js

@@ -59,6 +59,17 @@ const repositorySchema = z.object({
         merge_queue_check_name: z.string().min(1).optional(),
     }).optional(),
 });
+const promptLayerSchema = z.object({
+    extra_instructions_file: z.string().min(1).optional(),
+    replace_sections: z.record(z.string().min(1), z.string().min(1)).default({}),
+});
+const promptByRunTypeSchema = z.object({
+    implementation: promptLayerSchema.optional(),
+    review_fix: promptLayerSchema.optional(),
+    branch_upkeep: promptLayerSchema.optional(),
+    ci_repair: promptLayerSchema.optional(),
+    queue_repair: promptLayerSchema.optional(),
+});
 const configSchema = z.object({
     server: z.object({
         bind: z.string().default("127.0.0.1"),
@@ -121,6 +132,17 @@ const configSchema = z.object({
             experimental_raw_events: z.boolean().default(true),
         }),
     }),
+    prompting: z.object({
+        default: promptLayerSchema.default({
+            replace_sections: {},
+        }),
+        by_run_type: promptByRunTypeSchema.default({}),
+    }).default({
+        default: {
+            replace_sections: {},
+        },
+        by_run_type: {},
+    }),
     repos: z.object({
         root: z.string().min(1).default(path.join(homedir(), "projects")),
     }).default(() => ({ root: path.join(homedir(), "projects") })),
@@ -164,6 +186,7 @@ function withSectionDefaults(input) {
         logging: {},
         database: {},
         operator_api: {},
+        prompting: {},
         repos: {},
         projects: [],
         repositories: [],
@@ -181,6 +204,24 @@ function withSectionDefaults(input) {
 function resolveRepoSettingsPath(repoPath) {
     return path.join(repoPath, REPO_SETTINGS_DIRNAME, REPO_SETTINGS_FILENAME);
 }
+function readPromptFile(configDir, filePath) {
+    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath);
+    if (!existsSync(resolvedPath)) {
+        throw new Error(`Prompt file not found: ${resolvedPath}`);
+    }
+    return {
+        sourcePath: resolvedPath,
+        content: readFileSync(resolvedPath, "utf8").trim(),
+    };
+}
+function loadPromptLayer(configDir, layer) {
+    return {
+        ...(layer.extra_instructions_file
+            ? { extraInstructions: readPromptFile(configDir, layer.extra_instructions_file) }
+            : {}),
+        replaceSections: Object.fromEntries(Object.entries(layer.replace_sections).map(([sectionId, fragmentPath]) => [sectionId, readPromptFile(configDir, fragmentPath)])),
+    };
+}
 function expandEnv(value, env) {
     if (typeof value === "string") {
         return value.replace(/\$\{([A-Z0-9_]+)(?::-(.*?))?\}/g, (_match, name, fallback) => {
@@ -322,6 +363,7 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
     };
     const parsedFile = parseJsonFile(requestedPath, "config file");
     const parsed = configSchema.parse(withSectionDefaults(expandEnv(parsedFile, env)));
+    const configDir = path.dirname(requestedPath);
     const requirements = getLoadProfileRequirements(profile);
     const rWebhookSecret = resolveSecretWithSource("linear-webhook-secret", parsed.linear.webhook_secret_env, env);
     const rTokenEncryptionKey = resolveSecretWithSource("token-encryption-key", parsed.linear.token_encryption_key_env, env);
@@ -487,6 +529,12 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
                 experimentalRawEvents: parsed.runner.codex.experimental_raw_events,
             },
         },
+        prompting: {
+            default: loadPromptLayer(configDir, parsed.prompting.default),
+            byRunType: Object.fromEntries(Object.entries(parsed.prompting.by_run_type)
+                .filter(([, layer]) => Boolean(layer))
+                .map(([runType, layer]) => [runType, loadPromptLayer(configDir, layer)])),
+        },
         repos: {
             root: reposRoot,
         },

package/dist/patchrelay-customization.js

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+const promptLayerSchema = z.object({
+    extraInstructionsFile: z.string().min(1).optional(),
+    replaceSections: z.record(z.string().min(1), z.string().min(1)).default({}),
+});
+const promptByRunTypeSchema = z.object({
+    implementation: promptLayerSchema.optional(),
+    review_fix: promptLayerSchema.optional(),
+    branch_upkeep: promptLayerSchema.optional(),
+    ci_repair: promptLayerSchema.optional(),
+    queue_repair: promptLayerSchema.optional(),
+});
+const patchRelayCustomizationSchema = z.object({
+    version: z.literal(1),
+    prompt: z.object({
+        default: promptLayerSchema.default({
+            replaceSections: {},
+        }),
+        byRunType: promptByRunTypeSchema.default({}),
+    }).default({
+        default: {
+            replaceSections: {},
+        },
+        byRunType: {},
+    }),
+});
+function configPath(repoRoot) {
+    return path.join(repoRoot, ".patchrelay", "patchrelay.json");
+}
+function readPromptFile(repoRoot, filePath) {
+    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(repoRoot, filePath);
+    if (!existsSync(resolvedPath)) {
+        throw new Error(`Prompt file not found: ${resolvedPath}`);
+    }
+    return {
+        sourcePath: resolvedPath,
+        content: readFileSync(resolvedPath, "utf8").trim(),
+    };
+}
+function loadPromptLayer(repoRoot, layer) {
+    return {
+        ...(layer?.extraInstructionsFile
+            ? { extraInstructions: readPromptFile(repoRoot, layer.extraInstructionsFile) }
+            : {}),
+        replaceSections: Object.fromEntries(Object.entries(layer?.replaceSections ?? {})
+            .map(([sectionId, fragmentPath]) => [sectionId, readPromptFile(repoRoot, fragmentPath)])),
+    };
+}
+export function loadPatchRelayRepoPrompting(params) {
+    try {
+        const filePath = configPath(params.repoRoot);
+        if (!existsSync(filePath)) {
+            return undefined;
+        }
+        const raw = readFileSync(filePath, "utf8");
+        const parsed = patchRelayCustomizationSchema.parse(JSON.parse(raw));
+        return {
+            default: loadPromptLayer(params.repoRoot, parsed.prompt.default),
+            byRunType: Object.fromEntries(Object.entries(parsed.prompt.byRunType).map(([runType, layer]) => [runType, loadPromptLayer(params.repoRoot, layer)])),
+        };
+    }
+    catch (error) {
+        params.logger.warn({ error: error instanceof Error ? error.message : String(error), repoRoot: params.repoRoot }, "PatchRelay repo prompt customization could not be loaded");
+        return undefined;
+    }
+}