@the-open-engine/zeroshot 6.38.1 → 6.39.1

package/src/omp-execution-fingerprint.ts

@@ -0,0 +1,92 @@
+// The `executionFingerprint` recorded with every resumable OMP session (issue #866).
+//
+// A session transcript is only safely continuable under the same execution contract that produced
+// it. This digest binds that contract: the pinned OMP release, the Zeroshot config overlay's
+// content, the requested Zeroshot selectors (`--model`, `--thinking`, `--approval-mode`), and the
+// concrete provider/model/thinking level OMP actually reported for the turn. Any of those drifting
+// between the recording turn and a resume attempt — a Zeroshot upgrade that retunes the overlay, a
+// changed level mapping, an alias resolving to a different concrete model, a different thinking
+// level — makes the fingerprints differ, and the continuation is refused before the prompt.
+import { createHash } from 'crypto';
+
+interface ConfigOverlayFacade {
+  readonly OMP_CONFIG_OVERLAY_DIGEST: string;
+}
+
+interface CommandSpec {
+  readonly args?: unknown;
+}
+
+interface OmpSessionEvidence {
+  readonly selectedProvider?: unknown;
+  readonly selectedModel?: unknown;
+  readonly thinkingLevel?: unknown;
+}
+
+interface FingerprintParams {
+  readonly expectedVersion: unknown;
+  readonly commandSpec: CommandSpec | null | undefined;
+  readonly evidence: OmpSessionEvidence | null | undefined;
+  readonly configOverlayDigest?: unknown;
+}
+
+interface RequestedExecutionSelectors {
+  readonly modelSelector: string;
+  readonly thinkingSelector: string;
+  readonly approvalMode: string;
+}
+
+// The generated CommonJS module resolves the maintained overlay at the matching runtime path.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { OMP_CONFIG_OVERLAY_DIGEST }: ConfigOverlayFacade = require('./omp-config-overlay');
+
+/** Value of `--flag <value>` in an argv array, or '' when the flag is absent. */
+function flagValue(args: unknown, flag: string): string {
+  if (!Array.isArray(args)) return '';
+  const index = args.indexOf(flag);
+  if (index < 0 || index + 1 >= args.length) return '';
+  const value: unknown = args[index + 1];
+  return typeof value === 'string' ? value : '';
+}
+
+/** The Zeroshot-requested half of the contract, readable from the command spec alone. */
+function requestedExecutionSelectors(
+  commandSpec: CommandSpec | null | undefined
+): RequestedExecutionSelectors {
+  const args = commandSpec?.args;
+  return {
+    modelSelector: flagValue(args, '--model'),
+    thinkingSelector: flagValue(args, '--thinking'),
+    approvalMode: flagValue(args, '--approval-mode'),
+  };
+}
+
+/** Compute the deterministic digest for the requested and observed OMP execution contract. */
+function computeOmpExecutionFingerprint({
+  expectedVersion,
+  commandSpec,
+  evidence,
+  configOverlayDigest = OMP_CONFIG_OVERLAY_DIGEST,
+}: FingerprintParams): string {
+  const fields: Record<string, string> = {
+    ompSupportedVersion: String(expectedVersion ?? ''),
+    configOverlayDigest: String(configOverlayDigest ?? ''),
+    ...requestedExecutionSelectors(commandSpec),
+    observedProvider: String(evidence?.selectedProvider ?? ''),
+    observedModel: String(evidence?.selectedModel ?? ''),
+    observedThinkingLevel: String(evidence?.thinkingLevel ?? ''),
+  };
+  const stable: Record<string, string> = {};
+  // Fingerprints preserve ECMAScript's locale-independent UTF-16 code-unit ordering.
+  // eslint-disable-next-line sonarjs/no-alphabetical-sort
+  for (const key of Object.keys(fields).sort()) {
+    const value = fields[key];
+    if (value !== undefined) stable[key] = value;
+  }
+  return `sha256:${createHash('sha256').update(JSON.stringify(stable), 'utf8').digest('hex')}`;
+}
+
+export = {
+  computeOmpExecutionFingerprint,
+  requestedExecutionSelectors,
+};

package/src/omp-session-limits.js

@@ -1,19 +1,15 @@
-// Non-configurable bounds for OMP session partition verification (src/omp-session-verifier.js).
-// Every value is pinned exactly as specified by issue #866; do not derive these from settings or
-// environment — a configurable ceiling here would let a compromised/misbehaving OMP process (or a
-// hostile resumed partition) negotiate its own verification budget.
+"use strict";
 const OMP_SESSION_LIMITS = Object.freeze({
-  maxSessionBytes: 268435456,
-  maxSessionRecords: 1000000,
-  maxArtifactEntries: 4096,
-  maxArtifactDepth: 16,
-  maxRelativePathBytes: 4096,
-  maxArtifactFileBytes: 268435456,
-  maxArtifactAggregateBytes: 536870912,
-  maxBlobReferences: 4096,
-  maxReferencedBlobBytes: 67108864,
+    maxSessionBytes: 268435456,
+    maxSessionRecords: 1000000,
+    maxArtifactEntries: 4096,
+    maxArtifactDepth: 16,
+    maxRelativePathBytes: 4096,
+    maxArtifactFileBytes: 268435456,
+    maxArtifactAggregateBytes: 536870912,
+    maxBlobReferences: 4096,
+    maxReferencedBlobBytes: 67108864,
 });
-
 /**
  * The largest single JSONL record the verifier will buffer, DERIVED from the constants above
  * rather than chosen — it is `maxReferencedBlobBytes`, and it is not a new knob (there is nothing
@@ -37,5 +33,4 @@ const OMP_SESSION_LIMITS = Object.freeze({
  * verifier accumulates session, artifact, or blob bytes.
  */
 const MAX_SESSION_RECORD_BYTES = OMP_SESSION_LIMITS.maxReferencedBlobBytes;
-
 module.exports = { OMP_SESSION_LIMITS, MAX_SESSION_RECORD_BYTES };

package/src/omp-session-limits.ts

@@ -0,0 +1,53 @@
+// Non-configurable bounds for OMP session partition verification (src/omp-session-verifier.js).
+// Every value is pinned exactly as specified by issue #866; do not derive these from settings or
+// environment — a configurable ceiling here would let a compromised/misbehaving OMP process (or a
+// hostile resumed partition) negotiate its own verification budget.
+interface OmpSessionLimits {
+  readonly maxSessionBytes: number;
+  readonly maxSessionRecords: number;
+  readonly maxArtifactEntries: number;
+  readonly maxArtifactDepth: number;
+  readonly maxRelativePathBytes: number;
+  readonly maxArtifactFileBytes: number;
+  readonly maxArtifactAggregateBytes: number;
+  readonly maxBlobReferences: number;
+  readonly maxReferencedBlobBytes: number;
+}
+
+const OMP_SESSION_LIMITS: Readonly<OmpSessionLimits> = Object.freeze({
+  maxSessionBytes: 268435456,
+  maxSessionRecords: 1000000,
+  maxArtifactEntries: 4096,
+  maxArtifactDepth: 16,
+  maxRelativePathBytes: 4096,
+  maxArtifactFileBytes: 268435456,
+  maxArtifactAggregateBytes: 536870912,
+  maxBlobReferences: 4096,
+  maxReferencedBlobBytes: 67108864,
+});
+
+/**
+ * The largest single JSONL record the verifier will buffer, DERIVED from the constants above
+ * rather than chosen — it is `maxReferencedBlobBytes`, and it is not a new knob (there is nothing
+ * to configure and no caller may override it).
+ *
+ * Why a per-record bound is needed at all: `maxSessionBytes` bounds the *file*, not a line within
+ * it. A hostile 256 MiB session with no newline in it is one record, and buffering it would cost
+ * the raw bytes, a concatenated copy, a UTF-16 string for JSON.parse, and the parsed value — a
+ * multi-hundred-megabyte spike driven entirely by the attacker's choice of where to put newlines.
+ *
+ * Why this value: `maxReferencedBlobBytes` is the issue's own answer to "how large may one
+ * addressable unit of session content be". OMP externalizes anything bigger than a message to the
+ * shared CAS store (blob-store.ts) and leaves only a 76-byte `blob:sha256:<hex>` reference in the
+ * record, so a legitimate record is orders of magnitude smaller than this; the bound exists to cap
+ * the pathological case, not to constrain real transcripts.
+ *
+ * Remaining allocation, exactly: verification buffers at most MAX_SESSION_RECORD_BYTES of raw
+ * record bytes, and `JSON.parse` necessarily materializes that record as one UTF-16 string plus its
+ * parsed value. Peak per-record cost is therefore O(MAX_SESSION_RECORD_BYTES) and independent of
+ * `maxSessionBytes`, the record count, and the file's newline placement. Nothing else in the
+ * verifier accumulates session, artifact, or blob bytes.
+ */
+const MAX_SESSION_RECORD_BYTES = OMP_SESSION_LIMITS.maxReferencedBlobBytes;
+
+export = { OMP_SESSION_LIMITS, MAX_SESSION_RECORD_BYTES };

package/src/omp-session-partition.js

@@ -5,9 +5,9 @@ const { isInsideOmpBlobsDir } = require('./omp-blob-root');
 
 // Every OMP session partition lives under <storageRoot>/omp-sessions/<uuid>/. storageRoot is the
 // owning cluster's storageDir for cluster-agent tasks or the standalone TASKS_DIR otherwise (see
-// task-lib/omp-storage-root.js) — never derived from prompt text or cwd. The shared OMP CAS blob
+// task-lib/omp-storage-root.ts) — never derived from prompt text or cwd. The shared OMP CAS blob
 // store is *not* under here at all (it is machine-wide, at pi-utils::getBlobsDir(); see
-// src/omp-blob-root.js), which is what makes per-task partition deletion safe.
+// src/omp-blob-root.ts), which is what makes per-task partition deletion safe.
 const OMP_SESSIONS_SUBDIR = 'omp-sessions';
 const PARTITION_ID_PATTERN =
   /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;

package/src/omp-session-verifier.js

@@ -10,7 +10,7 @@
 // CAS blobs are NOT part of the partition. OMP externalizes large payloads to a *shared*,
 // machine-wide content-addressed store (`blob-store.ts`, rooted at `pi-utils::getBlobsDir()` —
 // `~/.omp/agent/blobs` modulo OMP's config-root/profile/XDG semantics, mirrored in
-// src/omp-blob-root.js) and leaves a *nested* `blob:sha256:<64-lower-hex>` reference string inside
+// src/omp-blob-root.ts) and leaves a *nested* `blob:sha256:<64-lower-hex>` reference string inside
 // the session JSONL records. So verification parses the JSONL, collects canonical nested refs, and
 // checks the referenced blobs at that real shared root. Nothing here ever writes to or deletes
 // from it (see src/omp-session-partition.js, which refuses any path resolving inside it).

package/src/orchestrator.js

@@ -262,6 +262,7 @@ function buildPrOptions(options, requiredQualityGates) {
     prBase: options.prBase || null,
     mergeQueue: options.mergeQueue || false,
     closeIssue: options.closeIssue || null,
+    prBody: typeof options.prBody === 'string' ? options.prBody : null,
     gitRemote: options.gitRemote || null,
     autoMerge,
     ...(requiredQualityGates.length > 0 ? { requiredQualityGates } : {}),
@@ -1847,16 +1848,31 @@ class Orchestrator {
             },
           },
         });
+        const boundary = this._clusterRunBoundaries.get(clusterId);
+        const complete = messageBus.query({
+          cluster_id: clusterId,
+          topic: 'CLUSTER_COMPLETE',
+          limit: 1,
+          ...(boundary === null || boundary === undefined ? {} : { afterId: boundary }),
+        })[0];
+        const failed = this._findCurrentRunClusterFailure(messageBus, clusterId);
+        if (!complete && !failed) {
+          messageBus.publish({
+            cluster_id: clusterId,
+            topic: 'CLUSTER_FAILED',
+            sender: 'orchestrator',
+            content: {
+              text: `Operation chain failed: ${err.message}`,
+              data: { reason: 'cluster_operations_failed' },
+            },
+          });
+        }
 
         this._log(`\n${'='.repeat(80)}`);
         this._log(`❌ CLUSTER_OPERATIONS FAILED - STOPPING CLUSTER`);
         this._log(`${'='.repeat(80)}`);
         this._log(`Error: ${err.message}`);
         this._log(`${'='.repeat(80)}\n`);
-
-        this.stop(clusterId).catch((stopErr) => {
-          console.error(`Failed to stop cluster after operation failure:`, stopErr.message);
-        });
       });
     });
   }
@@ -2023,6 +2039,7 @@ class Orchestrator {
       prBase: options.prBase,
       mergeQueue: options.mergeQueue,
       closeIssue: options.closeIssue,
+      prBody: options.prBody,
       requiredQualityGates: options.requiredQualityGates,
       autoMerge: resolveRunPlan(options).autoMerge,
       gitRemote: gitContext?.remote || options.gitRemote,
@@ -2140,8 +2157,16 @@ class Orchestrator {
     // NEVER pass --volumes (irreversible data loss) and NEVER tear down a pinned/shared
     // Compose project — only a project scoped to the worktree directory basename, which is
     // the only kind zeroshot could itself have created, is touched.
-    const { resolveWorktreeComposeTeardown } = require('../lib/compose-utils');
-    const teardown = resolveWorktreeComposeTeardown(worktreePath);
+    let teardown;
+    try {
+      const { resolveWorktreeComposeTeardown } = require('../lib/compose-utils');
+      teardown = resolveWorktreeComposeTeardown(worktreePath);
+    } catch (error) {
+      this._log(
+        `[Orchestrator] Skipping Docker Compose teardown in ${worktreePath}: ${error.message}`
+      );
+      return;
+    }
     if (!teardown.shouldTeardown) {
       if (teardown.composePath) {
         this._log(
@@ -4202,7 +4227,7 @@ Continue from where you left off. Review your previous output to understand what
 
       // Get issue context from ledger
       const issueMsg = cluster.messageBus.ledger.findLast({ topic: 'ISSUE_OPENED' });
-      const issueNumber = issueMsg?.content?.data?.number || 'unknown';
+      const issueNumber = issueMsg?.content?.data?.issue_number || 'unknown';
       const issueTitle = issueMsg?.content?.data?.title || 'Implementation';
 
       // Generate the final prompt in one typed assembly pass. Issue values are

package/src/pr-body-template.js

@@ -0,0 +1,71 @@
+const MAX_PR_BODY_LENGTH = 65536;
+
+function normalizeIssueNumber(value) {
+  const candidate = typeof value === 'number' ? String(value) : value;
+  if (typeof candidate !== 'string') return 'unknown';
+  const trimmed = candidate.trim();
+  return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(trimmed) ? trimmed : 'unknown';
+}
+
+function normalizeIssueTitle(value) {
+  if (typeof value !== 'string' || value.trim() === '') return 'Implementation';
+  const normalized = [...value]
+    .map((character) => {
+      const codePoint = character.codePointAt(0);
+      return codePoint < 0x20 || codePoint === 0x7f ? ' ' : character;
+    })
+    .join('')
+    .trim();
+  return normalized || 'Implementation';
+}
+
+function resolveIssueContext(options = {}) {
+  const issueNumber = normalizeIssueNumber(options.issueNumber);
+  const issueTitle = normalizeIssueTitle(options.issueTitle);
+  const issueReference =
+    options.includeIssueReference === false || issueNumber === 'unknown'
+      ? ''
+      : `Closes #${issueNumber}`;
+  return { issueNumber, issueTitle, issueReference };
+}
+
+function normalizePrBodyTemplate(value) {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== 'string') throw new TypeError('PR body template must be a string');
+  if (value.includes('\0')) throw new TypeError('PR body template must not contain NUL bytes');
+  if (value.length > MAX_PR_BODY_LENGTH) {
+    throw new TypeError(`PR body template must not exceed ${MAX_PR_BODY_LENGTH} characters`);
+  }
+  return value;
+}
+
+/**
+ * Render a bounded PR body. Missing issue metadata expands to empty text so
+ * manual tasks never leak internal sentinel values into pull requests.
+ */
+function renderPullRequestBody(template, options = {}) {
+  const issueContext = resolveIssueContext(options);
+  const normalizedTemplate = normalizePrBodyTemplate(template);
+  if (normalizedTemplate === null) return issueContext.issueReference;
+
+  const hasIssue = issueContext.issueNumber !== 'unknown';
+  const substitutions = {
+    '{{issue_number}}': hasIssue ? issueContext.issueNumber : '',
+    '{{issue_title}}': hasIssue ? issueContext.issueTitle : '',
+    '{{issue_reference}}': hasIssue ? issueContext.issueReference : '',
+  };
+  let rendered = normalizedTemplate;
+  for (const [token, replacement] of Object.entries(substitutions)) {
+    rendered = rendered.replaceAll(token, replacement);
+  }
+  if (rendered.length > MAX_PR_BODY_LENGTH) {
+    throw new TypeError(`Rendered PR body must not exceed ${MAX_PR_BODY_LENGTH} characters`);
+  }
+  return rendered;
+}
+
+module.exports = {
+  MAX_PR_BODY_LENGTH,
+  renderPullRequestBody,
+  resolveIssueContext,
+};

package/src/providers/anthropic/index.js

@@ -1,3 +1,5 @@
+"use strict";
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { createProviderClass } = require('..');
-
 module.exports = createProviderClass('claude');

package/src/providers/anthropic/index.ts

@@ -0,0 +1,13 @@
+interface ProviderConstructor {
+  new (): { readonly name: string };
+}
+
+interface ProvidersFacade {
+  createProviderClass(name: string): ProviderConstructor;
+}
+
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { createProviderClass }: ProvidersFacade = require('..');
+
+export = createProviderClass('claude');

package/src/providers/capabilities.js

@@ -1,33 +1,25 @@
-const {
-  PROVIDER_CAPABILITIES,
-  normalizeProviderName,
-  providerSupportsCapability,
-} = require('../../lib/provider-names');
-
-const CAPABILITIES = Object.freeze(
-  Object.fromEntries(
-    Object.entries(PROVIDER_CAPABILITIES).map(([provider, capabilities]) => [
-      provider,
-      Object.freeze({ ...capabilities }),
-    ])
-  )
-);
-
+"use strict";
+// The generated CommonJS facade resolves the built provider registry through lib/.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { PROVIDER_CAPABILITIES, normalizeProviderName, providerSupportsCapability } = require('../../lib/provider-names');
+const CAPABILITIES = Object.freeze(Object.fromEntries(Object.entries(PROVIDER_CAPABILITIES).map(([provider, capabilities]) => [
+    provider,
+    Object.freeze({ ...capabilities }),
+])));
 function checkCapability(provider, capability) {
-  if (!provider) return false;
-  return providerSupportsCapability(provider, capability);
+    if (!provider)
+        return false;
+    return providerSupportsCapability(provider, capability);
 }
-
 function warnIfExperimental(provider, capability) {
-  const normalized = normalizeProviderName(provider);
-  const caps = CAPABILITIES[normalized];
-  if (caps?.[capability] === 'experimental') {
-    console.warn(`⚠️ ${capability} is experimental for ${normalized} and may not work reliably`);
-  }
+    const normalized = normalizeProviderName(provider);
+    const caps = CAPABILITIES[normalized];
+    if (caps?.[capability] === 'experimental') {
+        console.warn(`⚠️ ${capability} is experimental for ${normalized} and may not work reliably`);
+    }
 }
-
 module.exports = {
-  CAPABILITIES,
-  checkCapability,
-  warnIfExperimental,
+    CAPABILITIES,
+    checkCapability,
+    warnIfExperimental,
 };

package/src/providers/capabilities.ts

@@ -0,0 +1,44 @@
+type ProviderCapabilityState = boolean | 'experimental';
+type ProviderCapabilities = Readonly<Record<string, ProviderCapabilityState>>;
+
+interface ProviderNamesFacade {
+  readonly PROVIDER_CAPABILITIES: Readonly<Record<string, ProviderCapabilities>>;
+  normalizeProviderName(provider: string): string;
+  providerSupportsCapability(provider: string, capability: string): boolean;
+}
+
+// The generated CommonJS facade resolves the built provider registry through lib/.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { PROVIDER_CAPABILITIES, normalizeProviderName, providerSupportsCapability }:
+  ProviderNamesFacade = require('../../lib/provider-names');
+
+const CAPABILITIES: Readonly<Record<string, ProviderCapabilities>> = Object.freeze(
+  Object.fromEntries(
+    Object.entries(PROVIDER_CAPABILITIES).map(([provider, capabilities]) => [
+      provider,
+      Object.freeze({ ...capabilities }),
+    ])
+  )
+);
+
+function checkCapability(
+  provider: string | null | undefined,
+  capability: string
+): boolean {
+  if (!provider) return false;
+  return providerSupportsCapability(provider, capability);
+}
+
+function warnIfExperimental(provider: string, capability: string): void {
+  const normalized = normalizeProviderName(provider);
+  const caps = CAPABILITIES[normalized];
+  if (caps?.[capability] === 'experimental') {
+    console.warn(`⚠️ ${capability} is experimental for ${normalized} and may not work reliably`);
+  }
+}
+
+export = {
+  CAPABILITIES,
+  checkCapability,
+  warnIfExperimental,
+};

package/src/providers/google/index.js

@@ -1,3 +1,5 @@
+"use strict";
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { createProviderClass } = require('..');
-
 module.exports = createProviderClass('gemini');

package/src/providers/google/index.ts

@@ -0,0 +1,13 @@
+interface ProviderConstructor {
+  new (): { readonly name: string };
+}
+
+interface ProvidersFacade {
+  createProviderClass(name: string): ProviderConstructor;
+}
+
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { createProviderClass }: ProvidersFacade = require('..');
+
+export = createProviderClass('gemini');

package/src/providers/openai/index.js

@@ -1,3 +1,5 @@
+"use strict";
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { createProviderClass } = require('..');
-
 module.exports = createProviderClass('codex');

package/src/providers/openai/index.ts

@@ -0,0 +1,13 @@
+interface ProviderConstructor {
+  new (): { readonly name: string };
+}
+
+interface ProvidersFacade {
+  createProviderClass(name: string): ProviderConstructor;
+}
+
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { createProviderClass }: ProvidersFacade = require('..');
+
+export = createProviderClass('codex');

package/src/providers/opencode/index.js

@@ -1,3 +1,5 @@
+"use strict";
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { createProviderClass } = require('..');
-
 module.exports = createProviderClass('opencode');

package/src/providers/opencode/index.ts

@@ -0,0 +1,13 @@
+interface ProviderConstructor {
+  new (): { readonly name: string };
+}
+
+interface ProvidersFacade {
+  createProviderClass(name: string): ProviderConstructor;
+}
+
+// The generated CommonJS entrypoint resolves the maintained provider facade one directory up.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const { createProviderClass }: ProvidersFacade = require('..');
+
+export = createProviderClass('opencode');