omp-conductor 0.15.9 → 0.15.11

package/src/commands/upgrade-rollback.ts

@@ -0,0 +1,23 @@
+/**
+ * `upgrade-rollback` — the detached rollback unit (#486).
+ *
+ * Reads the state-dir upgrade journal, restores every surface the failed
+ * install touched from the durable pre-install snapshot, reloads the services
+ * the install reloaded, and writes the outcome back to the journal plus the
+ * durable outbox. Runs as its own transient unit so the restarts it performs
+ * pass it by — the same trust boundary as the install: the process that rolls
+ * back is not the process that failed.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { rollbackFromJournal } from "../upgrade.ts";
+
+export async function upgradeRollbackCommand(ctx: CommandContext): Promise<void> {
+  const result = await rollbackFromJournal();
+  process.stdout.write(
+    `rolled back to omp-conductor@${result.restoredVersion} after the failed ` +
+      `upgrade to ${result.failedVersion}\n` +
+      `  surfaces   restored from the pre-install snapshot\n` +
+      `  dispatch   paused — the next tick verifies the old version and resumes\n`,
+  );
+}

package/src/commands/upgrade.ts

@@ -0,0 +1,25 @@
+/**
+ * `upgrade` — update the Bun-global CLI, omp plugin, Herdr recovery plugin and brief as one pinned release.
+ *
+ * Moved out of cli.ts's switch by the per-verb module split (#462);
+ * only the case wrapper, the injected `ctx` lookups and the imports
+ * changed from the original bodies.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { upgradeConductor } from "../upgrade.ts";
+
+export async function upgradeCommand(ctx: CommandContext): Promise<void> {
+const result = await upgradeConductor({
+  version: ctx.flag("to"),
+  project: ctx.projectFlag,
+});
+process.stdout.write(
+  `${result.alreadyCurrent ? "already current" : "upgrade complete"}:\n` +
+    `  Bun-global CLI     omp-conductor@${result.version}\n` +
+    `  omp plugin         omp-conductor@${result.version}\n` +
+    `  Herdr plugin       herdr-conductor@${result.gitHead}\n` +
+    `  orchestrator brief managed ORCHESTRATOR.md floor current; POLICY.md preserved\n` +
+    `  dispatch           ${result.dispatch}${result.alreadyCurrent ? "" : " restored"}\n`,
+);
+}

package/src/commands/verb.ts

@@ -0,0 +1,83 @@
+/**
+ * `verb` — run one `conductor_*` verb as the orchestrator, from the CLI: through the daemon's own checks and ledger rows.
+ *
+ * Moved out of cli.ts's switch by the per-verb module split (#462);
+ * only the case wrapper, the injected `ctx` lookups and the imports
+ * changed from the original bodies.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { findProject, loadConfig } from "../config.ts";
+import { isPaused, pausedAt } from "../daemon.ts";
+import { readBaseChain } from "../gitops.ts";
+import { dbPath, openStore } from "../store.ts";
+import { makeTracker } from "../tracker/github.ts";
+import { VERB_NAMES } from "../types.ts";
+import { githubVerbActions } from "../verbs/actions.ts";
+import { handleVerbCall, type VerbChannel } from "../verbs/server.ts";
+
+export async function verbCommand(ctx: CommandContext): Promise<void> {
+const name = ctx.argv[1];
+if (name === undefined || !VERB_NAMES.some((n) => n === name)) {
+  process.stderr.write(
+    `omp-conductor: unknown verb "${name ?? ""}". Known verbs: ${VERB_NAMES.join(", ")}\n`,
+  );
+  process.exit(2);
+}
+const cfg = loadConfig();
+const project = findProject(cfg, ctx.projectFlag);
+const args: Record<string, string> = {};
+for (let i = 2; i < ctx.argv.length; i++) {
+  const token = ctx.argv[i];
+  if (token === "--arg") {
+    const pair = ctx.argv[i + 1];
+    if (pair === undefined || !pair.includes("=")) {
+      process.stderr.write(`omp-conductor: verb --arg needs k=v, got "${pair ?? ""}"\n`);
+      process.exit(2);
+    }
+    const eq = pair.indexOf("=");
+    args[pair.slice(0, eq)] = pair.slice(eq + 1);
+    i++;
+  } else if (token === "--project" || token?.startsWith("--project=") === true) {
+    // Consumed by `ctx.projectFlag` above; both spellings skip here.
+    if (token === "--project") i++;
+  } else {
+    process.stderr.write(
+      `omp-conductor: verb: unexpected argument "${token ?? ""}" (pass verb arguments as --arg k=v)\n`,
+    );
+    process.exit(2);
+  }
+}
+const store = openStore(dbPath());
+try {
+  const channel: VerbChannel = {
+    kind: "orchestrator",
+    path: "cli",
+    project: project.name,
+    role: "orchestrator",
+  };
+  const reply = await handleVerbCall(
+    {
+      project: () => findProject(loadConfig(), project.name),
+      store,
+      tracker: makeTracker(project),
+      actions: githubVerbActions(project),
+      fleetStop: () =>
+        isPaused(project.name)
+          ? "claiming is paused for this fleet (omp-conductor hold or stop)"
+          : undefined,
+      pausedAt: () => pausedAt(project.name),
+      log: (m) => process.stderr.write(`${m}\n`),
+      now: () => Date.now(),
+      chain: { readBaseChain },
+    },
+    channel,
+    { verb: name, args },
+  );
+  process.stdout.write(`${reply.text}\n`);
+  // A refusal must not read as success to a script calling this.
+  if (!reply.ok) process.exitCode = 3;
+} finally {
+  store.close();
+}
+}

package/src/commands/version.ts

@@ -0,0 +1,30 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * The installed package version, read from the package manifest once per run.
+ * The path is one level deeper than cli.ts's original — this module lives in
+ * src/commands/ — but resolves to the same omp/package.json.
+ */
+function packageVersion(): string {
+  const parsed = JSON.parse(
+    readFileSync(join(import.meta.dir, "..", "..", "package.json"), "utf8"),
+  ) as {
+    version?: unknown;
+  };
+  if (typeof parsed.version !== "string" || parsed.version.length === 0) {
+    throw new Error("installed package.json has no version");
+  }
+  return parsed.version;
+}
+
+/**
+ * `--version`, `-V` and `version`: print the installed package version.
+ *
+ * Moved out of cli.ts's switch by the per-verb module split (#462); only the
+ * case wrapper and the imports changed from the original body.
+ */
+
+export async function versionCommand(): Promise<void> {
+  process.stdout.write(`${packageVersion()}\n`);
+}

package/src/commands/worker.ts

@@ -0,0 +1,100 @@
+/**
+ * `worker` — pause/resume/stop one live worker session through the daemon's run-control HTTP endpoints.
+ *
+ * Moved out of cli.ts's switch by the per-verb module split (#462);
+ * only the case wrapper, the injected `ctx` lookups and the imports
+ * changed from the original bodies.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { findProject, loadConfig } from "../config.ts";
+import { livingDaemon } from "../lifecycle.ts";
+
+export async function workerCommand(ctx: CommandContext): Promise<void> {
+const sub = ctx.argv[1];
+if (sub !== "pause" && sub !== "resume" && sub !== "stop") {
+  process.stderr.write(
+    "omp-conductor: worker needs pause, resume, or stop, then an issue number\n",
+  );
+  process.exit(2);
+}
+const issue = ctx.issueArg("worker", ctx.argv[2]);
+const rawReason = sub === "stop" ? ctx.flag("reason") : undefined;
+const reason = rawReason?.trim().replace(/\s+/g, " ");
+if (sub === "stop" && (reason === undefined || reason === "" || reason.length > 500)) {
+  process.stderr.write(
+    "omp-conductor: worker stop needs --reason with 1-500 characters\n",
+  );
+  process.exit(2);
+}
+const project = findProject(loadConfig(), ctx.projectFlag);
+const daemon = livingDaemon();
+if (daemon === undefined) throw new Error("daemon is not running");
+if (daemon.project !== undefined && daemon.project !== project.name) {
+  throw new Error(
+    `daemon serves project "${daemon.project}", not requested project "${project.name}"`,
+  );
+}
+const response = await fetch(
+  `http://127.0.0.1:${daemon.port}/runs/${issue}/${sub}`,
+  {
+    method: "PUT",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      project: project.name,
+      ...(reason === undefined ? {} : { reason }),
+    }),
+  },
+);
+const payload = (await response.json()) as {
+  error?: unknown;
+  runId?: unknown;
+  phase?: unknown;
+  outcome?: unknown;
+  state?: unknown;
+  reason?: unknown;
+  salvageSha?: unknown;
+  salvageError?: unknown;
+  worktree?: unknown;
+};
+if (!response.ok) {
+  throw new Error(
+    typeof payload.error === "string" ? payload.error : `daemon returned HTTP ${response.status}`,
+  );
+}
+if (sub === "stop") {
+  if (
+    typeof payload.runId !== "string" ||
+    typeof payload.state !== "string" ||
+    (payload.outcome !== "stopped" && payload.outcome !== "already-terminal")
+  ) {
+    throw new Error("daemon returned an invalid worker-stop response");
+  }
+  if (payload.outcome === "already-terminal") {
+    process.stdout.write(
+      `#${issue} worker already terminal: ${payload.state} (run ${payload.runId})\n`,
+    );
+    return;
+  }
+  if (typeof payload.reason !== "string") {
+    throw new Error("daemon returned an invalid worker-stop response");
+  }
+  process.stdout.write(
+    `#${issue} worker stopped (run ${payload.runId}): ${payload.reason}\n`,
+  );
+  if (typeof payload.salvageSha === "string") {
+    process.stdout.write(`work preserved: ${payload.salvageSha}\n`);
+  }
+  if (typeof payload.salvageError === "string") {
+    process.stdout.write(
+      `WIP SALVAGE FAILED: ${payload.salvageError}\n` +
+      `worktree kept: ${typeof payload.worktree === "string" ? payload.worktree : "(path unavailable)"}\n`,
+    );
+  }
+  return;
+}
+if (typeof payload.runId !== "string" || typeof payload.phase !== "string") {
+  throw new Error("daemon returned an invalid worker-control response");
+}
+process.stdout.write(`#${issue} worker ${payload.phase} (run ${payload.runId})\n`);
+}

package/src/config-schema.ts

@@ -226,6 +226,7 @@ const authoritySchema = z
   .object({
     merge: authorityHolderEnum.default(DEFAULT_AUTHORITY.merge),
     release: authorityHolderEnum.default(DEFAULT_AUTHORITY.release),
+    promotion: authorityHolderEnum.default(DEFAULT_AUTHORITY.promotion),
   })
   .strict();
 
@@ -352,7 +353,43 @@ export const ConfigSchema = configSchema;
  * validate a hand-written config against the same vocabulary the loader enforces.
  */
 export function configJsonSchema(): object {
-  return z.toJSONSchema(ConfigSchema) as object;
+  return unrequireDefaultedKeys(z.toJSONSchema(ConfigSchema) as object);
+}
+
+/** True for a JSON object value (null and arrays excluded). */
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+/**
+ * zod's JSON-Schema renderer lists a field carrying `.default(...)` as
+ * `required` anyway — its required computation keys off optionality, while
+ * the only trace a default leaves in the output is the `default` annotation.
+ * The loader accepts a config that omits any defaulted key, so a schema that
+ * demands one rejects a file the daemon reads cleanly (the pre-#469
+ * back-compat promise). Walk the rendered schema and drop every `required`
+ * key whose property schema declares a `default`; a key with no default is
+ * untouched. Works in place on the tree `z.toJSONSchema` just built.
+ */
+function unrequireDefaultedKeys(schema: object): object {
+  if (Array.isArray(schema)) {
+    for (const item of schema) if (isObject(item)) unrequireDefaultedKeys(item);
+    return schema;
+  }
+  const node = schema as Record<string, unknown>;
+  const properties = node.properties;
+  if (isObject(properties) && Array.isArray(node.required)) {
+    const kept = (node.required as unknown[]).filter((key) => {
+      const property = properties[String(key)];
+      return !isObject(property) || !("default" in property);
+    });
+    if (kept.length === 0) delete node.required;
+    else node.required = kept;
+  }
+  for (const value of Object.values(node)) {
+    if (isObject(value)) unrequireDefaultedKeys(value);
+  }
+  return schema;
 }
 
 // Re-exports the renderer consumes without duplicating the lists.

package/src/config.ts

@@ -558,13 +558,17 @@ function checkDigest(d: Raw, label: string, problems: string[]): void {
 function checkAuthority(a: Raw, label: string, problems: string[]): void {
   const merge = a["merge"];
   const release = a["release"];
+  const promotion = a["promotion"];
   if (merge !== undefined && typeof merge === "string" && !(AUTHORITY_HOLDERS as readonly string[]).includes(merge)) {
     problems.push(`${label}: authority.merge must be ${AUTHORITY_HOLDER_LIST}, found ${JSON.stringify(merge)}`);
   }
   if (release !== undefined && typeof release === "string" && !(AUTHORITY_HOLDERS as readonly string[]).includes(release)) {
     problems.push(`${label}: authority.release must be ${AUTHORITY_HOLDER_LIST}, found ${JSON.stringify(release)}`);
   }
-  const unknown = Object.keys(a).filter((k) => k !== "merge" && k !== "release");
+  if (promotion !== undefined && typeof promotion === "string" && !(AUTHORITY_HOLDERS as readonly string[]).includes(promotion)) {
+    problems.push(`${label}: authority.promotion must be ${AUTHORITY_HOLDER_LIST}, found ${JSON.stringify(promotion)}`);
+  }
+  const unknown = Object.keys(a).filter((k) => k !== "merge" && k !== "release" && k !== "promotion");
   if (unknown.length > 0) problems.push(`${label}: authority has unknown key(s): ${unknown.join(", ")}`);
 }
 
@@ -817,7 +821,7 @@ function clauseFor(rel: readonly PropertyKey[], issue: {
     }
     if (rel.length === 1 && relStr === "escalation") return `escalation must be an object`;
     if (rel.length === 1 && relStr === "authority") {
-      return `authority must be an object with "merge" and "release" of ${AUTHORITY_HOLDER_LIST}`;
+      return `authority must be an object with "merge", "release" and "promotion" of ${AUTHORITY_HOLDER_LIST}`;
     }
     if (rel.length === 1 && relStr === "policy") {
       return `policy must be an object with "merge" and "release" sections`;
@@ -909,7 +913,7 @@ function clauseFor(rel: readonly PropertyKey[], issue: {
     }
     if (pathStr === "reporting.digest.cadence") return `${pathStr} must be ${DIGEST_CADENCE_LIST}, found ${found()}`;
     if (pathStr === "escalation.orchestrator") return `${pathStr} must be ${ORCHESTRATOR_MODE_LIST}, found ${found()}`;
-    if (pathStr === "authority.merge" || pathStr === "authority.release") {
+    if (pathStr === "authority.merge" || pathStr === "authority.release" || pathStr === "authority.promotion") {
       return `${pathStr} must be ${AUTHORITY_HOLDER_LIST}, found ${found()}`;
     }
     if (pathStr === "policy.merge.baseFreshness") return `${pathStr} must be ${BASE_FRESHNESS_LIST}, found ${found()}`;
@@ -1136,6 +1140,9 @@ function finalizeAuthority(parsed: Raw | undefined): ProjectConfig["authority"]
   return {
     merge: (parsed["merge"] as ProjectConfig["authority"]["merge"]) ?? DEFAULT_AUTHORITY.merge,
     release: (parsed["release"] as ProjectConfig["authority"]["release"]) ?? DEFAULT_AUTHORITY.release,
+    // Unstated defaults to the human: a config written before promotion was a
+    // key must load as operator-owned, never as a silent delegation.
+    promotion: (parsed["promotion"] as ProjectConfig["authority"]["promotion"] | undefined) ?? DEFAULT_AUTHORITY.promotion,
   };
 }