omp-conductor 0.14.0 → 0.15.0

package/src/graph.ts

@@ -214,7 +214,7 @@ export function reindexScript(p: ProjectConfig): string {
     "#!/usr/bin/env bash",
     `# Refresh and reindex the code graphs for omp-conductor project "${p.name}".`,
     "#",
-    "# Generated by \`omp-conductor graph-setup\`. Regenerate it rather than editing:",
+    "# Generated by \`omp-conductor setup graph\`. Regenerate it rather than editing:",
     "# the repo list, branches and paths all come from that project's config.json.",
     "#",
     "# Every clone below is conductor's own, index-only and never edited by a human,",
@@ -437,7 +437,7 @@ export function formatGraphSetup(
   const script = reindexScriptPath();
   const { service, timer } = unitPaths(stateDir());
   lines.push(
-    `   \`graph-setup --write\` writes these three files for you, all under`,
+    `   \`omp-conductor setup graph\` writes these three files for you, all under`,
     `   ${stateDir()}. Run it as the account the fleet runs as — never under`,
     "   sudo, which would resolve the config, the state directory and the unit's",
     "   own User= as root and quietly build indexes no worker can read.",
@@ -453,7 +453,7 @@ export function formatGraphSetup(
   return lines.join("\n");
 }
 
-/** What `graph-setup --write` did, and the root-only steps it deliberately left. */
+/** What staging wrote, and the root-only steps it deliberately left. */
 export interface GraphSetupWrite {
   written: string[];
   next: string;

package/src/host.ts

@@ -62,6 +62,22 @@ export function recommendedMaxWorkers(ramBytes: number | undefined): number {
   return ramBytes < SMALL_HOST_RAM_BYTES ? 1 : DEFAULT_CAPS.maxConcurrentWorkers;
 }
 
+/**
+ * Warning shown when all configured projects can outgrow this host together.
+ *
+ * Omitting `ram` probes the host. Passing `undefined` explicitly means "RAM is
+ * unknown" and must NOT fall through to a host probe — a default parameter would
+ * treat that `undefined` as "use the default", which is how CI on a small box
+ * made `workerOvercommit(2, undefined)` warn about capacity 1.
+ */
+export function workerOvercommit(total: number, ram?: number | undefined): string | undefined {
+  const effective = arguments.length < 2 ? hostRamBytes() : ram;
+  const recommended = recommendedMaxWorkers(effective);
+  return total > recommended
+    ? `Configured worker capacity ${total} exceeds this host's recommended maximum of ${recommended}.`
+    : undefined;
+}
+
 /** Compact binary units for status lines (`3.2 GB`, `430 MB`). */
 export function formatRss(bytes: number): string {
   if (!Number.isFinite(bytes) || bytes < 0) return "?";

package/src/omp.ts

@@ -18,7 +18,7 @@ import { createServer, type Server, type Socket } from "node:net";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
-import { worktreeConfinement } from "./confinement.ts";
+import { readOnlySession, worktreeConfinement } from "./confinement.ts";
 import { releasePolicyTripwire, type ReleaseBlockContext } from "./release-policy.ts";
 import type {
   HostToParent,
@@ -168,6 +168,15 @@ export async function createLocalSession(opts: {
    * leave the model to improvise `git push` instead.
    */
   verbSocketPath?: string;
+  /**
+   * Deny every tool but reading and searching (#307).
+   *
+   * For sessions asked to *read* a repository and answer a question — the setup
+   * probes. Distinct from {@link worktreeConfinement}, which scopes where writes
+   * may land: this removes the shell, the editors and the verbs entirely, so the
+   * session has no route to a mutation to scope in the first place.
+   */
+  readOnly?: boolean;
 }): Promise<AgentSessionLike> {
   let loaded: unknown;
   try {
@@ -205,6 +214,9 @@ export async function createLocalSession(opts: {
   // transcript is the only record of what the worker actually did.
   const sessionManager = await openSessionManager(mod, opts);
   const extensions = [
+    // Read-only sessions get the deny-by-default gate *first*, so an unknown tool
+    // is refused before any later extension can form an opinion about it.
+    ...(opts.readOnly === true ? [readOnlySession()] : []),
     // Workers only. The orchestrator runs unconfined by operator ruling
     // (#143): the gate could only ever be installed in sessions this daemon
     // spawns, so an external orchestrator — the supported shape — never had it,
@@ -430,6 +442,13 @@ export interface CreateSessionOptions {
    * without a live harness or a model bill.
    */
   hostModule?: string;
+  /**
+   * Deny every tool but reading and searching (#307).
+   *
+   * Forwarded to the child, because that is where the session — and therefore the
+   * gate — actually lives.
+   */
+  readOnly?: boolean;
 }
 
 /**
@@ -499,6 +518,7 @@ export async function createSession(opts: CreateSessionOptions): Promise<AgentSe
     ...(opts.resume === undefined ? {} : { resume: opts.resume }),
     ...(opts.releaseGrants === undefined ? {} : { releaseGrants: opts.releaseGrants }),
     ...(opts.verbSocketPath === undefined ? {} : { verbSocketPath: opts.verbSocketPath }),
+    ...(opts.readOnly === undefined ? {} : { readOnly: opts.readOnly }),
   };
 
   const log = opts.onChildLog ?? ((line: string) => process.stderr.write(`${line}\n`));

package/src/orchestrator-tick.ts

@@ -25,7 +25,7 @@
  *
  * Beyond those three gates, every tick carries the project's `reporting.scope`
  * as one explicit constraint line, re-read from the conductor config on each
- * tick so a `/conductor setup` change binds the next heartbeat rather than
+ * tick so an `omp-conductor setup` change binds the next heartbeat rather than
  * waiting for a session restart — and one delivery rule
  * ({@link TICK_DELIVERY_RULE}), because a tick is injected locally and a report
  * written as end-of-turn text on such a turn reaches nobody. An operator's own
@@ -49,7 +49,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { availabilityPrompt, interruptDisposition } from "./availability.ts";
-import { findProject, loadConfig, resolveReleaseGrants } from "./config.ts";
+import { findProject, loadConfig, resolveReleaseGrants, stateDir } from "./config.ts";
 import {
   bridgeTokenBound,
   hasBotToken,
@@ -153,13 +153,18 @@ const PENDING_MESSAGE_GRACE_MS = 60_000;
 const DEFAULT_GROOM_BELOW = 4;
 
 /**
- * Written by herdr-conductor `recover.sh` *before* `agent start`, so a resumed
- * fleet can reconcile orphans without waiting a full `intervalSeconds`. Cleared
- * only after a tick is actually sent — a disarmed or channel-down fleet keeps
- * the request until gates pass (or a human removes the file).
+ * Written by herdr-conductor `recover.sh` *before* `agent start`, and by the
+ * dispatch daemon when a watched decision condition transitions false→true
+ * (#329), so the orchestrator can reconcile without waiting a full
+ * `intervalSeconds`. Cleared only after a tick is actually sent — a disarmed or
+ * channel-down fleet keeps the request until gates pass (or a human removes the
+ * file). Mid-interval the heartbeat polls for this file on a short cadence.
  */
 export const TICK_REQUESTED_FILE = ".conductor-tick-requested";
 
+/** How often a live heartbeat looks for {@link TICK_REQUESTED_FILE} between ticks. */
+const TICK_REQUEST_POLL_MS = 10_000;
+
 /** Runtime heartbeat schedule consumed by `omp-conductor status`. */
 export const TICK_STATUS_FILE = ".conductor-tick-status.json";
 
@@ -213,9 +218,9 @@ const PENDING_REASON = "tick already pending";
  * The slice of the omp extension API this entry touches, mirroring
  * `ExtensionAPI` / `ExtensionContext` from `@oh-my-pi/pi-coding-agent`.
  *
- * Declared here rather than imported for the reason ./plugin.ts declares its
- * own: the harness is a peer dependency and the package has to type-check
- * without it installed. Structural typing means the real objects satisfy these
+ * Declared here rather than imported because the harness is a peer dependency and
+ * the package has to type-check without it installed — the same reason ./omp.ts
+ * loads the SDK dynamically. Structural typing means the real objects satisfy these
  * on the way in.
  */
 interface TickLogger {
@@ -312,6 +317,19 @@ interface TickApi {
  *  they get here. */
 export interface TickConfig {
   intervalSeconds: number;
+  /**
+   * The conductor project this fleet session ticks for, stamped by `setup host`
+   * (one tick config per fleet cwd). It is what lets a host with several
+   * configured projects resolve *this* fleet's brief, reporting policy, digest
+   * ledger and release grants, instead of asking `findProject` a question it
+   * refuses to guess through.
+   *
+   * Omitted is the pre-multi-project spelling. Resolution then falls back to the
+   * un-named `findProject`: exact for a single-project fleet — which must keep
+   * behaving exactly as it did — and ambiguous, therefore degrading, for more
+   * than one.
+   */
+  project?: string;
   armedFile?: string;
   accessFile?: string;
   message?: string;
@@ -682,7 +700,7 @@ export function formatFrictionDigest(signals: readonly FrictionSignal[]): string
  * config could not answer — why.
  *
  * Read on every tick rather than cached at session start, for the reason the
- * channel gate is: the operator re-runs `/conductor setup` while this session
+ * channel gate is: the operator re-runs `omp-conductor setup` while this session
  * lives, and a heartbeat holding a startup snapshot would keep injecting the
  * old contract until somebody restarted it.
  *
@@ -698,8 +716,15 @@ export function formatFrictionDigest(signals: readonly FrictionSignal[]): string
  * none named — the same ambiguity `findProject` refuses to guess through for
  * `status`. Stopping the heartbeat over either preference would be the worse
  * trade.
+ *
+ * `projectName` is {@link TickConfig.project}, stamped per fleet cwd, and it is
+ * the whole difference between a two-project host resolving each fleet's own
+ * contract and both of them degrading. Omitted (a pre-multi-project tick config)
+ * keeps the un-named lookup, which only a host with more than one project can
+ * fail — and that host gets {@link LEGACY_TICK_PROJECT_HINT} naming the one
+ * command that fixes it.
  */
-export function resolveTickScope(): {
+export function resolveTickScope(projectName?: string): {
   scope: ReportScopeChoice;
   policy?: ReportingPolicy;
   briefPath?: string;
@@ -707,8 +732,14 @@ export function resolveTickScope(): {
   projectName?: string;
   fallback?: string;
 } {
+  // Counted before `findProject` can throw, because "several projects and this
+  // tick config names none" is the one fault with a one-command remedy and the
+  // only way to tell it apart from "no config at all" is the count.
+  let projects = 0;
   try {
-    const project = findProject(loadConfig());
+    const config = loadConfig();
+    projects = config.projects.length;
+    const project = findProject(config, projectName);
     return {
       scope: reportScopeFromPolicy(project.reporting),
       policy: project.reporting,
@@ -717,8 +748,109 @@ export function resolveTickScope(): {
       projectName: project.name,
     };
   } catch (err) {
-    return { scope: DEFAULT_REPORT_SCOPE, fallback: err instanceof Error ? err.message : String(err) };
+    const problem = err instanceof Error ? err.message : String(err);
+    const unstamped = projectName === undefined && projects > 1;
+    return { scope: DEFAULT_REPORT_SCOPE, fallback: unstamped ? `${problem} ${LEGACY_TICK_PROJECT_HINT}` : problem };
+  }
+}
+
+/**
+ * The fix for the one degradation an operator can clear in a single command: a
+ * tick config written before {@link TickConfig.project} existed, on a host that
+ * has since gained a second project.
+ */
+export const LEGACY_TICK_PROJECT_HINT =
+  "Re-run `omp-conductor setup host` to stamp the project into .conductor-tick.json.";
+
+/**
+ * Whether a tick config found on disk belongs to the project being asked about.
+ *
+ * Search roots overlap — `stateDir()` and the shared parent of two fleet cwds
+ * are read for every project — so without this a stray config in a shared root
+ * answers for whichever project asked first, and `setup host` would restamp one
+ * project's file while planning another. An unstamped config matches anything,
+ * which is what keeps a single-project fleet on its existing file.
+ */
+export function tickConfigMatchesProject(config: TickConfig, projectName?: string): boolean {
+  if (projectName === undefined || config.project === undefined) return true;
+  return config.project === projectName;
+}
+
+/**
+ * Directory that owns this project's {@link TICK_CONFIG_FILE}, if one is
+ * present and stamped for the project (or unstamped on a single-project host).
+ * Used by out-of-process writers of {@link TICK_REQUESTED_FILE} — the dispatch
+ * daemon must not import `fleet.ts` (fleet already imports daemon).
+ */
+export function resolveTickConfigCwd(projectName?: string): string | undefined {
+  const roots: string[] = [stateDir()];
+  try {
+    const p = findProject(loadConfig(), projectName);
+    const parent = dirname(p.workspaceRoot);
+    if (parent !== roots[0]) roots.push(parent);
+    if (p.workspaceRoot !== roots[0] && p.workspaceRoot !== parent) roots.push(p.workspaceRoot);
+  } catch {
+    /* no config */
+  }
+  for (const cwd of roots) {
+    const r = readTickConfig(cwd);
+    if (r.kind === "ok") {
+      if (!tickConfigMatchesProject(r.config, projectName)) continue;
+      return cwd;
+    }
+    if (r.kind === "invalid") return undefined;
   }
+  return undefined;
+}
+
+/** The shared, pre-per-project arm marker: `<stateDir>/armed`. */
+export function legacyArmedMarkerPath(): string {
+  return join(stateDir(), "armed");
+}
+
+/** What `status` says about a bare `armed` marker that no tick will honour. */
+export const LEGACY_ARM_MARKER_DETAIL =
+  "legacy global arm marker — re-run setup host, then arm per project";
+
+/**
+ * Whether the arm gate is open, and whether the shared pre-per-project marker is
+ * what decided it.
+ *
+ * Two migrations meet here. A single-project fleet whose `armedFile` has just
+ * been restamped from `armed` to `armed-<name>` must not be silently disarmed by
+ * the upgrade, so its bare `armed` marker still counts (`legacy: "honoured"`). A
+ * host with more than one project cannot let one marker arm every fleet — that is
+ * the collision this issue removes — so there the bare marker arms nothing and
+ * says so instead (`legacy: "stranded"`), including for a tick config that still
+ * names it directly.
+ *
+ * The fallback reaches exactly two `armedFile` spellings: the shared path itself,
+ * and the per-project path the restamp replaces it with. An operator's own gate
+ * — any other value, which `setup host` deliberately preserves — is the gate; its
+ * absence means disarmed however many stale markers lie around it.
+ *
+ * The config is read only when a legacy marker is actually in play, so the
+ * healthy path costs one string compare. An unreadable or absent config is
+ * treated as single-project: a host with no conductor config cannot be a
+ * multi-project host, and 0.14 behaviour is the honest default there.
+ */
+export type ArmState = { armed: boolean; legacy?: "honoured" | "stranded" };
+
+export function resolveArmState(armedFile: string, projectName?: string): ArmState {
+  const legacy = legacyArmedMarkerPath();
+  const shared = armedFile === legacy;
+  if (!shared && existsSync(armedFile)) return { armed: true };
+  const migratable =
+    shared || (projectName !== undefined && armedFile === join(stateDir(), `armed-${projectName}`));
+  if (!migratable || !existsSync(legacy)) return { armed: false };
+  let multiProject = false;
+  try {
+    multiProject = loadConfig().projects.length > 1;
+  } catch {
+    // No readable config: not a multi-project host, so keep 0.14 behaviour.
+  }
+  if (multiProject) return { armed: false, legacy: "stranded" };
+  return shared ? { armed: true } : { armed: true, legacy: "honoured" };
 }
 
 /**
@@ -730,9 +862,9 @@ export function resolveTickScope(): {
  * the default prompt path. Failures (no config, no `POLICY.md`, unreadable
  * overlay) are silent: the tick still goes out.
  */
-export function refreshComposedBriefBestEffort(): boolean {
+export function refreshComposedBriefBestEffort(projectName?: string): boolean {
   try {
-    return refreshComposedBriefForProject(findProject(loadConfig()));
+    return refreshComposedBriefForProject(findProject(loadConfig(), projectName));
   } catch {
     return false;
   }
@@ -822,6 +954,16 @@ export function readTickConfig(cwd: string): TickConfigResult {
     }
   }
 
+  const projectRaw = raw["project"];
+  let project: string | undefined;
+  if (projectRaw !== undefined) {
+    if (typeof projectRaw !== "string" || projectRaw.trim().length === 0) {
+      problems.push("project must be a non-empty string when present");
+    } else {
+      project = projectRaw.trim();
+    }
+  }
+
   if (problems.length > 0) return { kind: "invalid", path, problem: problems.join("; ") };
 
   return {
@@ -829,6 +971,7 @@ export function readTickConfig(cwd: string): TickConfigResult {
     path,
     config: {
       intervalSeconds,
+      ...(project === undefined ? {} : { project }),
       ...(budgetSeconds === undefined ? {} : { budgetSeconds }),
       ...(armedFile === undefined ? {} : { armedFile }),
       ...(accessFile === undefined ? {} : { accessFile }),
@@ -991,9 +1134,17 @@ export function paneOwnership(input: { paneId: string; agentName: string; agents
   if (mine?.name !== undefined) {
     // A registered agent, just not this fleet's. herdr can name several omp
     // agents in one directory, and requiring merely *a* name would arm each one.
+    //
+    // The rename hint is conditional because this branch has two very different
+    // causes: a scratch pane that is correctly named something else, and the
+    // fleet's own pane still carrying the name it had before its tick config was
+    // restamped for a project. Only the operator knows which.
     return {
       kind: "declined",
-      reason: `this pane is agent "${mine.name}", not the fleet agent "${input.agentName}" — this session will not tick`,
+      reason:
+        `this pane is agent "${mine.name}", not the fleet agent "${input.agentName}" — ` +
+        `if this is the fleet pane under an old name, \`herdr agent rename ${input.paneId} ${input.agentName}\`; ` +
+        `this session will not tick`,
     };
   }
 
@@ -1008,12 +1159,19 @@ export function paneOwnership(input: { paneId: string; agentName: string; agents
   // No name here and nobody else holding it: an ad-hoc pane in the fleet's
   // directory, which is exactly the session that must stay inert. Fail-closed,
   // and the fix is named — an orchestrator that lost its registration is one
-  // `herdr agent start` from ticking again.
+  // `herdr agent rename` from ticking again.
+  //
+  // Deliberately NOT `herdr agent start`: that submits omp *into* the pane's
+  // existing shell and requires a pane at a shell prompt hosting no agent
+  // (herdr/README.md). This pane is running the omp session reading this line, so
+  // `agent start` would either be refused or start a second orchestrator in it.
+  // `rename` names the agent herdr already detects, and touches no process.
   return {
     kind: "declined",
     reason:
       `this pane is not a registered herdr agent, and no pane is running the fleet agent ` +
-      `"${input.agentName}" — register it with \`herdr agent start ${input.agentName} --kind omp --pane ${input.paneId}\`; ` +
+      `"${input.agentName}" — name its running agent with ` +
+      `\`herdr agent rename ${input.paneId} ${input.agentName}\`; ` +
       `this session will not tick`,
   };
 }
@@ -1340,18 +1498,58 @@ function clearStallMarker(pi: TickApi, cwd: string): void {
   }
 }
 
+/**
+ * Best-effort poke that asks a live orchestrator heartbeat to fire soon.
+ *
+ * Same file shape as herdr `recover.sh`: one line `${iso} ${reason}`. Writers
+ * (recover, the dispatch daemon on a false→true condition) never clear it —
+ * only a successful tick send does, so a disarmed or channel-down fleet keeps
+ * the request until gates pass.
+ */
+export function requestImmediateTick(cwd: string, reason: string): boolean {
+  const path = join(cwd, TICK_REQUESTED_FILE);
+  const label = reason.trim().length > 0 ? reason.trim() : "wake";
+  try {
+    writeFileSync(path, `${new Date().toISOString()} ${label}\n`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** First non-empty token after the optional ISO stamp on a poke line. */
+export function readTickRequestReason(cwd: string): string | undefined {
+  const path = join(cwd, TICK_REQUESTED_FILE);
+  if (!existsSync(path)) return undefined;
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return undefined;
+  }
+  const line = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
+  if (line.length === 0) return undefined;
+  const parts = line.split(/\s+/);
+  if (parts.length === 0) return undefined;
+  // recover.sh writes `${iso} recover`; a bare reason is also accepted.
+  if (parts.length >= 2 && Number.isFinite(Date.parse(parts[0]!))) {
+    return parts.slice(1).join(" ");
+  }
+  return parts.join(" ");
+}
+
 /**
  * Best-effort, same posture as {@link clearStallMarker}. Leaving the file on a
  * failed unlink means the next successful send retries the clear; that is
- * preferable to treating a recover poke as fire-and-forget when the tick did
- * land.
+ * preferable to treating a recover/condition poke as fire-and-forget when the
+ * tick did land.
  */
 function clearTickRequest(pi: TickApi, cwd: string): void {
   const path = join(cwd, TICK_REQUESTED_FILE);
   if (!existsSync(path)) return;
   try {
     rmSync(path, { force: true });
-    pi.logger.info("[omp-conductor] recover tick request cleared: a tick was sent");
+    pi.logger.info("[omp-conductor] tick request cleared: a tick was sent");
   } catch (err) {
     pi.logger.error(`[omp-conductor] could not remove ${path}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -1609,6 +1807,13 @@ interface TickSession {
   pendingSkips: number;
   /** Ticks sent as follow-ups but not yet observed by the agent loop. */
   pendingLocalTicks: PendingLocalTick[];
+  /**
+   * Whether the stranded shared arm marker has been named. Latched for
+   * {@link TickSession.scopeFallbackLogged}'s reason: a host that gained a
+   * second project without re-running setup would otherwise repeat the same
+   * line every interval, forever.
+   */
+  legacyArmLogged: boolean;
   /** The local tick whose agent loop is currently running, if any. */
   activeLocalTick?: ActiveLocalTick;
 }
@@ -1619,8 +1824,15 @@ interface TickSession {
  * otherwise emit a notification every interval, forever.
  */
 function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSession): void {
+  const arm = config.armedFile === undefined ? undefined : resolveArmState(config.armedFile, config.project);
+  if (arm?.legacy === "stranded" && !session.legacyArmLogged) {
+    session.legacyArmLogged = true;
+    pi.logger.error(
+      `[omp-conductor] ${legacyArmedMarkerPath()}: ${LEGACY_ARM_MARKER_DETAIL} — this heartbeat stays disarmed`,
+    );
+  }
   const decision = tickDecision({
-    armed: config.armedFile === undefined || existsSync(config.armedFile),
+    armed: arm === undefined || arm.armed,
     channelOk: config.accessFile === undefined || channelIsUp(config.accessFile),
     hasPending: ctx.hasPendingMessages(),
   });
@@ -1647,9 +1859,9 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
 
   // Floor refresh is independent of which prompt we send: a custom message still
   // expects ORCHESTRATOR.md / AGENTS.md to track the installed package.
-  refreshComposedBriefBestEffort();
+  refreshComposedBriefBestEffort(config.project);
 
-  const scope = resolveTickScope();
+  const scope = resolveTickScope(config.project);
   // The transport contract, read once from the same file at the same moment so
   // the approval line, the delivery rule and the narration line cannot disagree
   // (#169, #179). No access file means no fleet channel to judge; a session
@@ -1789,7 +2001,10 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
         // tracker (#181). A failed config read skips the line rather than
         // wedging the tick.
         try {
-          const project = findProject(loadConfig());
+          // Named: this block is already inside `scope.projectName !== undefined`,
+          // so the resolved name is in hand and an un-named lookup would refuse
+          // to guess on a host with a second project.
+          const project = findProject(loadConfig(), scope.projectName);
           const queue = queueDigestLine(
             frictionStore.latestDispatch(scope.projectName),
             project.queueLabel,
@@ -1873,6 +2088,11 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
   // No `accessFile` means no fleet bridge to judge, exactly as above.
   if (profile?.kind === "interactive") content = `${content}\n${TICK_NARRATION_RULE}`;
 
+  // Recover / condition-met pokes are auditable: the same reason the writer put
+  // on the sentinel line lands in the prompt and the "tick sent" log.
+  const wakeReason = readTickRequestReason(ctx.cwd);
+  if (wakeReason !== undefined) content = `${content}\nWake reason: ${wakeReason}`;
+
   const pendingLocalTick: PendingLocalTick = {
     id: randomUUID(),
     ...(scope.projectName === undefined ? {} : { projectName: scope.projectName }),
@@ -1906,13 +2126,19 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
   } finally {
     frictionStore?.close();
   }
-  pi.logger.info(`[omp-conductor] tick sent: ${decision.reason}`, { reason: decision.reason });
+  pi.logger.info(
+    wakeReason === undefined
+      ? `[omp-conductor] tick sent: ${decision.reason}`
+      : `[omp-conductor] tick sent: ${decision.reason} (wake: ${wakeReason})`,
+    { reason: decision.reason, ...(wakeReason === undefined ? {} : { wakeReason }) },
+  );
   // An empty queue at send time is the proof the previous tick was consumed, so
   // this is the only place either the counter or the marker is cleared.
   session.pendingSkips = 0;
   clearStallMarker(pi, ctx.cwd);
-  // Recover poke is consumed only on a real send — gates still apply above.
+  // Immediate-tick poke is consumed only on a real send — gates still apply above.
   clearTickRequest(pi, ctx.cwd);
+
 }
 
 function writeTickRuntimeStatus(pi: TickApi, cwd: string, intervalSeconds: number): void {
@@ -1933,22 +2159,40 @@ function writeTickRuntimeStatus(pi: TickApi, cwd: string, intervalSeconds: numbe
 }
 
 /**
- * Arm the interval heartbeat, then honour a recover poke if one is waiting.
+ * Arm the interval heartbeat, honour a poke already waiting at arm time, and
+ * poll mid-interval for later pokes (recover resume, condition-met #329).
  * Extracted so the ownership-retry path and the immediate-accept path cannot
- * drift: both must fire the same "do not wait a full interval after resume"
- * behaviour.
+ * drift: both must fire the same "do not wait a full interval after a poke"
+ * behaviour. Every path still runs {@link tick} → {@link tickDecision}, so a
+ * live turn coalesces rather than stacking concurrent ticks.
  */
 function armTickHeartbeat(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSession): void {
   writeTickRuntimeStatus(pi, ctx.cwd, config.intervalSeconds);
-  ctx.setInterval(() => {
+  const runScheduledTick = (): void => {
     try {
       tick(pi, ctx, config, session);
     } finally {
       writeTickRuntimeStatus(pi, ctx.cwd, config.intervalSeconds);
     }
-  }, config.intervalSeconds * 1000);
+  };
+  ctx.setInterval(runScheduledTick, config.intervalSeconds * 1000);
+  // Short mid-interval poll so a condition that flips between heartbeats does
+  // not wait a full cycle. Cap at the heartbeat itself so a misconfigured short
+  // interval cannot arm a second timer faster than the primary.
+  const pollMs = Math.min(TICK_REQUEST_POLL_MS, config.intervalSeconds * 1000);
+  if (pollMs < config.intervalSeconds * 1000) {
+    ctx.setInterval(() => {
+      if (!existsSync(join(ctx.cwd, TICK_REQUESTED_FILE))) return;
+      const reason = readTickRequestReason(ctx.cwd) ?? "wake";
+      pi.logger.info(
+        `[omp-conductor] tick requested by ${reason} — firing without waiting for the interval`,
+      );
+      runScheduledTick();
+    }, pollMs);
+  }
   if (!existsSync(join(ctx.cwd, TICK_REQUESTED_FILE))) return;
-  pi.logger.info("[omp-conductor] tick requested by recover — firing without waiting for the interval");
+  const reason = readTickRequestReason(ctx.cwd) ?? "wake";
+  pi.logger.info(`[omp-conductor] tick requested by ${reason} — firing without waiting for the interval`);
   tick(pi, ctx, config, session);
 }
 
@@ -2005,6 +2249,7 @@ export default function orchestratorTickExtension(pi: TickApi): void {
     bridgeTokenAtStart: true,
     pendingSkips: 0,
     pendingLocalTicks: [],
+    legacyArmLogged: false,
   };
   let releaseGateArmed = false;
   let availabilityGateArmed = false;
@@ -2013,7 +2258,14 @@ export default function orchestratorTickExtension(pi: TickApi): void {
   // which pane owns it. The gate therefore starts closed and only honours a
   // configured grant after ownership is accepted.
   let releaseAuthorityAccepted = false;
-  const armReleaseGate = (): void => {
+  /**
+   * `configuredProject` is {@link TickConfig.project}, and it is what stops a
+   * second configured project from collapsing every release grant this fleet
+   * really holds to {@link DENIED_RELEASE_GRANTS}. Undefined for a tick config
+   * that names none — including an invalid one, which arms this gate before the
+   * config can be trusted at all.
+   */
+  const armReleaseGate = (configuredProject?: string): void => {
     if (releaseGateArmed) return;
     releaseGateArmed = true;
     (pi as TickApi & {
@@ -2033,7 +2285,7 @@ export default function orchestratorTickExtension(pi: TickApi): void {
       let grants: ResolvedGrants = DENIED_RELEASE_GRANTS;
       let external = true;
       try {
-        const project = findProject(loadConfig());
+        const project = findProject(loadConfig(), configuredProject);
         projectName = project.name;
         grants = resolveReleaseGrants(project);
         external = project.escalation.orchestrator === "external";
@@ -2077,7 +2329,10 @@ export default function orchestratorTickExtension(pi: TickApi): void {
     });
   };
 
-  const armAvailabilityGate = (): void => {
+  /** `configuredProject` carries {@link TickConfig.project} for the same reason
+   *  {@link armReleaseGate} takes it: a recovered tick must reconstruct *this*
+   *  fleet's availability policy, not refuse to guess between two projects. */
+  const armAvailabilityGate = (configuredProject?: string): void => {
     if (availabilityGateArmed) return;
     availabilityGateArmed = true;
 
@@ -2095,7 +2350,7 @@ export default function orchestratorTickExtension(pi: TickApi): void {
           // A queued custom tick can survive a host restart after the in-memory
           // enqueue record does not. Reconstruct its scope so recovery cannot
           // silently turn an autonomous run into an interactive one.
-          const scope = resolveTickScope();
+          const scope = resolveTickScope(configuredProject);
           const id =
             typeof message.timestamp === "number"
               ? createHash("sha256").update(`recovered-tick\0${message.timestamp}`).digest("hex")
@@ -2158,8 +2413,12 @@ export default function orchestratorTickExtension(pi: TickApi): void {
 
     // Present but invalid still identifies a fleet directory. Install the
     // fail-closed handler before validation or ownership can return early.
-    armReleaseGate();
-    armAvailabilityGate();
+    // The project this fleet cwd ticks for, so both gates resolve its own policy
+    // rather than collapsing fail-closed on a host with a second project. An
+    // invalid config names none — it cannot be trusted to.
+    const configuredProject = result.kind === "ok" ? result.config.project : undefined;
+    armReleaseGate(configuredProject);
+    armAvailabilityGate(configuredProject);
 
     if (result.kind === "invalid") {
       const detail = `${result.path}: ${result.problem}`;