@intentius/chant 0.49.0 → 0.50.0

package/src/fold/subset.test.ts

@@ -74,10 +74,12 @@ const SUPPORTED_CASES: SubsetCase[] = [
 
 const UNSUPPORTED_CASES: SubsetCase[] = [
   { name: "function call as a value", expr: `getName()` },
-  { name: "method call as a value", expr: `config.getName()` },
-  // chant #1082 — a registered helper NAME reached through a namespace is
-  // still a method call, and still rejected by both sides.
-  { name: "registered helper name reached as a method", expr: `helpers.phase("Apply", [])` },
+  // chant #1966 moved "method call as a value" and "registered helper name
+  // reached as a method" out of this strict-parity list and into "documented
+  // divergences" below — a method call now folds when its receiver resolves,
+  // which is exactly the identifier-resolution asymmetry every other
+  // divergence there already documents.
+  //
   // ...and a registered helper with an unfoldable argument is rejected on the
   // argument, by both sides, at the argument's own position.
   { name: "registered helper with an unfoldable argument", expr: `phase("Apply", [getName()])` },
@@ -258,28 +260,85 @@ describe("documented divergences — NOT unified by design (see subset.ts module
     expect(evl001NonLiteralExpressionRule.check(context)).toHaveLength(0);
   });
 
-  test("composite step access: fold still rejects a call as a value; EVL001 accepts .step access (chant #1544, opt-in only)", () => {
+  test("method call on an unresolved receiver: fold rejects; EVL001 accepts the shape (chant #1966, resolution-dependent)", () => {
+    // `config.getName()` — chant #1966 widened `findSubsetViolation` to
+    // accept a method call unconditionally (mirroring `.step` and a nested
+    // `new` before it), because whether the receiver resolves to a value
+    // with that method is resolution-dependent (module doc, point 1) and out
+    // of reach for a syntax-only classifier. fold() still rejects it here on
+    // the receiver: `config` isn't a `const` this file has.
+    const source = `const bad = new Thing({ x: config.getName() });`;
+    const sourceFile = ts.createSourceFile("t.ts", source, ts.ScriptTarget.Latest, true);
+    const consts = collectConsts(sourceFile);
+    const badInit = consts.get("bad") as ts.NewExpression;
+
+    expect(() => foldResource(badInit, consts, [])).toThrow(FoldError);
+
+    const context: LintContext = { sourceFile, entities: [], filePath: "t.ts", lexicon: undefined };
+    expect(evl001NonLiteralExpressionRule.check(context)).toHaveLength(0);
+  });
+
+  test("registered helper name reached as a method: not the registered call, on either side — rejected for a different reason since #1966", () => {
+    // chant #1082 — a registered helper NAME reached through a namespace is
+    // still a method call, never the bare registered call: `fold()`'s
+    // `{__helper}` shape only ever matches a BARE identifier callee, so
+    // `helpers.phase(...)` never gets that treatment, before or after #1966.
+    // What changed is WHY it's rejected — `helpers` is an unresolved
+    // identifier now reached through the general method-call case, not "no
+    // case for a property-access callee" — same divergence direction as the
+    // test above.
+    const source = `const bad = new Thing({ x: helpers.phase("Apply", []) });`;
+    const sourceFile = ts.createSourceFile("t.ts", source, ts.ScriptTarget.Latest, true);
+    const consts = collectConsts(sourceFile);
+    const badInit = consts.get("bad") as ts.NewExpression;
+
+    let error: unknown;
+    try {
+      foldResource(badInit, consts, []);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeInstanceOf(FoldError);
+    expect((error as FoldError).message).toContain("unresolved identifier: helpers");
+
+    const context: LintContext = { sourceFile, entities: [], filePath: "t.ts", lexicon: undefined };
+    expect(evl001NonLiteralExpressionRule.check(context)).toHaveLength(0);
+  });
+
+  test("composite step access: NO LONGER a divergence (chant #1174) — both fold and EVL001 accept it", () => {
     // `Checkout({...}).step` — the single-action Composite() wrapper idiom
     // every lexicon's own docs/examples embed inline inside a Job's
-    // `steps:` array. fold() has no way to invoke an arbitrary composite
-    // factory, so it still rejects this shape and falls the file back to
-    // the run path (documented, correct behavior — never an error). EVL001
-    // now opts INTO treating it as shape-valid via `allowCompositeStepAccess`
-    // — a caller of `findSubsetViolation` that does not pass that flag
-    // (fold(), or this very call below) is completely unaffected.
+    // `steps:` array. This was a documented, EVL-only-permissive divergence
+    // from chant #1544 until #1174: `fold()` had no way to invoke an
+    // arbitrary composite factory, so it fell the file back to run
+    // (correct, not an error) while EVL001 already opted into treating the
+    // shape as valid via a since-removed `allowCompositeStepAccess` flag.
+    //
+    // fold() now folds this to a `{__compositeStep, args}` envelope
+    // (../fold/fold.ts) that ../discovery/fold-import.ts's bridge resolves
+    // through the folding file's own imports — interpreted when the callee
+    // is a project-file registered Composite (chant #1023), invoked for
+    // real otherwise (every lexicon-package composite, which is what
+    // `Checkout` is) — and reads `.step` off the REAL result. Kept as a
+    // test rather than deleted: the assertion that the divergence stays
+    // closed.
     const source = `const bad = new Thing({ x: Checkout({}).step });`;
     const sourceFile = ts.createSourceFile("t.ts", source, ts.ScriptTarget.Latest, true);
     const consts = collectConsts(sourceFile);
     const badInit = consts.get("bad") as ts.NewExpression;
 
-    expect(() => foldResource(badInit, consts, [])).toThrow(FoldError);
+    expect(foldResource(badInit, consts, [])).toEqual({
+      __resource: "Thing",
+      props: { x: { __compositeStep: "Checkout", args: [{}] } },
+    });
 
-    // findSubsetViolation with no third argument (fold()'s own answer, and
-    // every pre-#1544 caller) is unchanged — still a violation.
-    const bareCallExpr = (badInit.arguments![0] as ts.ObjectLiteralExpression).properties[0];
-    expect(findSubsetViolation(bareCallExpr)).toBeDefined();
+    // findSubsetViolation (fold()'s own shared predicate, no opt-in needed
+    // anymore) agrees the shape is admissible.
+    const stepAccessExpr = (
+      (badInit.arguments![0] as ts.ObjectLiteralExpression).properties[0] as ts.PropertyAssignment
+    ).initializer;
+    expect(findSubsetViolation(stepAccessExpr)).toBeUndefined();
 
-    // EVL001 itself opts in and stops flagging it.
     const context: LintContext = { sourceFile, entities: [], filePath: "t.ts", lexicon: undefined };
     expect(evl001NonLiteralExpressionRule.check(context)).toHaveLength(0);
   });
@@ -378,10 +437,14 @@ describe("findSubsetViolation — optional intrinsic registry (#1044)", () => {
     expect(v?.message).toContain("function call as a value is not foldable: Ref(...)");
   });
 
-  test("the registry doesn't widen anything else: a name in it without the opt-in, a method call, and .map all stay violations", () => {
+  test("the registry doesn't widen anything else: a name in it without the opt-in, a closure-taking method, and a plain call stay violations", () => {
     const notOptedIn: IntrinsicDef[] = [{ name: "Reference", isTag: false }];
     expect(findSubsetViolation(propValue(`Reference("db")`), notOptedIn)).toBeDefined();
-    expect(findSubsetViolation(propValue(`aws.Ref("db")`), REF)).toBeDefined();
+    // chant #1966 — `aws.Ref("db")` is a method call (`Ref` reached through a
+    // namespace, not a bare identifier), so it's no longer here: shape-wise
+    // it's now the same resolution-dependent divergence
+    // "method call on an unresolved receiver" documents above, unrelated to
+    // whether `Ref` itself is opted into `foldsAsCall`.
     expect(findSubsetViolation(propValue(`cidrs.map((c) => c)`, `const cidrs = [];`), REF)).toBeDefined();
     expect(findSubsetViolation(propValue(`makeName("a")`), REF)).toBeDefined();
   });

package/src/fold/subset.ts

@@ -1,6 +1,6 @@
 import * as ts from "typescript";
 import { isFoldableHelperName } from "./foldable-helpers";
-import { intrinsicCallFolds, type IntrinsicDef } from "../lexicon";
+import { intrinsicCallFolds, intrinsicCallFoldsEagerly, type IntrinsicDef } from "../lexicon";
 
 /**
  * subset — the single canonical definition of chant's statically-foldable
@@ -231,19 +231,18 @@ export function unsupportedExpressionMessage(node: ts.Node): string {
 export function checkObjectMember(
   prop: ts.ObjectLiteralElementLike,
   intrinsics?: readonly IntrinsicDef[],
-  allowCompositeStepAccess?: boolean,
 ): SubsetViolation | undefined {
   if (ts.isPropertyAssignment(prop)) {
     if (!isLiteralPropertyName(prop.name)) {
       return violation(prop.name, computedPropertyNameMessage(prop.name));
     }
-    return findSubsetViolation(prop.initializer, intrinsics, allowCompositeStepAccess);
+    return findSubsetViolation(prop.initializer, intrinsics);
   }
   if (ts.isShorthandPropertyAssignment(prop)) {
     return undefined;
   }
   if (ts.isSpreadAssignment(prop)) {
-    return findSubsetViolation(prop.expression, intrinsics, allowCompositeStepAccess);
+    return findSubsetViolation(prop.expression, intrinsics);
   }
   return violation(prop, UNSUPPORTED_OBJECT_MEMBER_MESSAGE);
 }
@@ -252,10 +251,9 @@ export function checkObjectMember(
 function checkArrayElement(
   el: ts.Expression,
   intrinsics?: readonly IntrinsicDef[],
-  allowCompositeStepAccess?: boolean,
 ): SubsetViolation | undefined {
-  if (ts.isSpreadElement(el)) return findSubsetViolation(el.expression, intrinsics, allowCompositeStepAccess);
-  return findSubsetViolation(el, intrinsics, allowCompositeStepAccess);
+  if (ts.isSpreadElement(el)) return findSubsetViolation(el.expression, intrinsics);
+  return findSubsetViolation(el, intrinsics);
 }
 
 /**
@@ -268,23 +266,29 @@ function checkArrayElement(
  * `fold()`-evaluation-order) unsupported node, or `undefined` when `node`'s
  * whole shape is foldable.
  *
- * `allowCompositeStepAccess` (chant #1544) is an EVL-only, MORE-permissive
- * divergence in the same direction as points 1/2/2b/2c in the module doc
- * above: a call immediately narrowed to a single member access — the
- * `Checkout({...}).step` shape every lexicon's single-action `Composite()`
- * wrappers document as their embedded-inline idiom (see composites.mdx —
- * "normally embedded inline as `checkout.step` inside a `Job`'s `steps`
- * array") — is treated as shape-valid. `fold()` itself never passes this
- * (it has no such parameter to pass; only EVL001 opts in), so `fold()`'s own
- * behavior is unchanged: it still falls the file back to the run path for
- * this shape, exactly as composites.mdx describes as the expected, correct
- * outcome — not an error. What changes is that EVL001 stops treating that
- * ordinary, documented fallback as a lint error.
+ * The `<call>(...).step` composite-consumer idiom (`Checkout({...}).step`,
+ * every lexicon's single-action `Composite()` wrapper embedded inline in a
+ * `Job`'s `steps` array — see composites.mdx) used to be an EVL-only,
+ * MORE-permissive divergence here (chant #1544's `allowCompositeStepAccess`
+ * opt-in parameter, since removed): `fold()` had no way to invoke an
+ * arbitrary composite factory, so it fell the file back to run for this
+ * shape (documented, correct behavior, never an error) while this shared
+ * predicate had to be told to stop treating that fallback as a lint error.
+ * chant #1174 closed the divergence — `fold()` now folds exactly this shape
+ * (narrowed to the literal member name `"step"`, the one idiom actually in
+ * use) — so this classifier accepts it unconditionally, the same way it
+ * already accepts a nested `new Type(...)` unconditionally since #1169.
+ *
+ * chant #1966 adds a CallExpression whose callee is a property access —
+ * `github.actor.toString()`, `matrix("os").toString()`, `[...].join(",")` —
+ * to the same unconditional-acceptance set: whether the receiver actually
+ * folds to a value with a callable method of that name is resolution-
+ * dependent (module doc, point 1), so this classifier stays permissive and
+ * only recurses into shape.
  */
 export function findSubsetViolation(
   node: ts.Node,
   intrinsics?: readonly IntrinsicDef[],
-  allowCompositeStepAccess?: boolean,
 ): SubsetViolation | undefined {
   if (
     ts.isParenthesizedExpression(node) ||
@@ -292,7 +296,7 @@ export function findSubsetViolation(
     ts.isSatisfiesExpression(node) ||
     ts.isNonNullExpression(node)
   ) {
-    return findSubsetViolation(node.expression, intrinsics, allowCompositeStepAccess);
+    return findSubsetViolation(node.expression, intrinsics);
   }
 
   if (
@@ -327,7 +331,7 @@ export function findSubsetViolation(
 
   if (ts.isTemplateExpression(node)) {
     for (const span of node.templateSpans) {
-      const v = findSubsetViolation(span.expression, intrinsics, allowCompositeStepAccess);
+      const v = findSubsetViolation(span.expression, intrinsics);
       if (v) return v;
     }
     return undefined;
@@ -335,7 +339,7 @@ export function findSubsetViolation(
 
   if (ts.isObjectLiteralExpression(node)) {
     for (const prop of node.properties) {
-      const v = checkObjectMember(prop, intrinsics, allowCompositeStepAccess);
+      const v = checkObjectMember(prop, intrinsics);
       if (v) return v;
     }
     return undefined;
@@ -343,35 +347,35 @@ export function findSubsetViolation(
 
   if (ts.isArrayLiteralExpression(node)) {
     for (const el of node.elements) {
-      const v = checkArrayElement(el, intrinsics, allowCompositeStepAccess);
+      const v = checkArrayElement(el, intrinsics);
       if (v) return v;
     }
     return undefined;
   }
 
   if (ts.isPropertyAccessExpression(node)) {
-    // chant #1544 — see this function's doc comment. `<call>(...).step`
-    // (any callee, any argument shape) is the composite-consumer idiom, EVL
-    // opt-in only: `fold()` never sets `allowCompositeStepAccess`, so it is
-    // unaffected and still falls back to the run path for this shape.
-    if (allowCompositeStepAccess && node.name.text === "step" && ts.isCallExpression(node.expression)) {
+    // chant #1174 — see this function's doc comment. `<call>(...).step`
+    // (any callee, any argument shape) is the composite-consumer idiom, and
+    // `fold()` now folds it too (narrowed to the literal member `"step"` —
+    // see fold.ts's PropertyAccessExpression branch).
+    if (node.name.text === "step" && ts.isCallExpression(node.expression)) {
       return undefined;
     }
-    return findSubsetViolation(node.expression, intrinsics, allowCompositeStepAccess);
+    return findSubsetViolation(node.expression, intrinsics);
   }
 
   if (ts.isElementAccessExpression(node)) {
     if (!isLiteralElementKey(node.argumentExpression)) {
       return violation(node.argumentExpression, dynamicElementAccessMessage(node.argumentExpression), "EVL003");
     }
-    return findSubsetViolation(node.expression, intrinsics, allowCompositeStepAccess);
+    return findSubsetViolation(node.expression, intrinsics);
   }
 
   if (ts.isPrefixUnaryExpression(node)) {
     if (!SUPPORTED_UNARY_OPERATORS.has(node.operator)) {
       return violation(node, UNSUPPORTED_UNARY_MESSAGE);
     }
-    return findSubsetViolation(node.operand, intrinsics, allowCompositeStepAccess);
+    return findSubsetViolation(node.operand, intrinsics);
   }
 
   if (ts.isBinaryExpression(node)) {
@@ -382,17 +386,17 @@ export function findSubsetViolation(
     // Flow-insensitive — see module doc: fold() short-circuits &&/||/?? and
     // only evaluates the taken side; EVL requires both sides shape-valid.
     return (
-      findSubsetViolation(node.left, intrinsics, allowCompositeStepAccess) ??
-      findSubsetViolation(node.right, intrinsics, allowCompositeStepAccess)
+      findSubsetViolation(node.left, intrinsics) ??
+      findSubsetViolation(node.right, intrinsics)
     );
   }
 
   if (ts.isConditionalExpression(node)) {
     // Flow-insensitive — see module doc: fold() only folds the taken branch.
     return (
-      findSubsetViolation(node.condition, intrinsics, allowCompositeStepAccess) ??
-      findSubsetViolation(node.whenTrue, intrinsics, allowCompositeStepAccess) ??
-      findSubsetViolation(node.whenFalse, intrinsics, allowCompositeStepAccess)
+      findSubsetViolation(node.condition, intrinsics) ??
+      findSubsetViolation(node.whenTrue, intrinsics) ??
+      findSubsetViolation(node.whenFalse, intrinsics)
     );
   }
 
@@ -403,14 +407,14 @@ export function findSubsetViolation(
     // argument is classified on its own terms and nothing is rejected merely
     // for being in the "wrong" position.
     for (const arg of node.arguments ?? []) {
-      const v = findSubsetViolation(arg, intrinsics, allowCompositeStepAccess);
+      const v = findSubsetViolation(arg, intrinsics);
       if (v) return v;
     }
     return undefined;
   }
 
   if (ts.isSpreadElement(node)) {
-    return findSubsetViolation(node.expression, intrinsics, allowCompositeStepAccess);
+    return findSubsetViolation(node.expression, intrinsics);
   }
 
   if (ts.isCallExpression(node)) {
@@ -426,7 +430,7 @@ export function findSubsetViolation(
     // ever be MORE permissive than `fold()`, never stricter.
     if (ts.isIdentifier(node.expression) && isFoldableHelperName(node.expression.text)) {
       for (const arg of node.arguments) {
-        const v = findSubsetViolation(arg, intrinsics, allowCompositeStepAccess);
+        const v = findSubsetViolation(arg, intrinsics);
         if (v) return v;
       }
       return undefined;
@@ -446,12 +450,46 @@ export function findSubsetViolation(
       intrinsics.some((i) => i.name === (node.expression as ts.Identifier).text && intrinsicCallFolds(i))
     ) {
       for (const arg of node.arguments) {
-        const v = findSubsetViolation(arg, intrinsics, allowCompositeStepAccess);
+        const v = findSubsetViolation(arg, intrinsics);
         if (v) return v;
       }
       return undefined;
     }
 
+    // chant #1966 — the eager counterpart of the #1044 case above: a lexicon
+    // intrinsic registered with `foldsEagerly` instead of `foldsAsCall`
+    // ({@link intrinsicCallFoldsEagerly}, ../lexicon.ts). Same registry-gated
+    // shape, same reasoning.
+    if (
+      intrinsics &&
+      ts.isIdentifier(node.expression) &&
+      intrinsics.some((i) => i.name === (node.expression as ts.Identifier).text && intrinsicCallFoldsEagerly(i))
+    ) {
+      for (const arg of node.arguments) {
+        const v = findSubsetViolation(arg, intrinsics);
+        if (v) return v;
+      }
+      return undefined;
+    }
+
+    // chant #1966 — a method call (`github.actor.toString()`, `[...].join(",")`,
+    // `matrix("os").toString()`): `fold()` now folds this shape unconditionally
+    // — the receiver must fold to a real value with the named method, which is
+    // resolution-dependent (module doc, point 1) and so out of reach for a
+    // syntax-only classifier, exactly the same asymmetry as `.step` above and
+    // a same-file `new` used as a value (#1169). Accepted here regardless of
+    // the intrinsics registry, unlike the two cases just above: nothing about
+    // whether a method call folds depends on a lexicon's registration.
+    if (ts.isPropertyAccessExpression(node.expression)) {
+      const v = findSubsetViolation(node.expression.expression, intrinsics);
+      if (v) return v;
+      for (const arg of node.arguments) {
+        const argViolation = findSubsetViolation(arg, intrinsics);
+        if (argViolation) return argViolation;
+      }
+      return undefined;
+    }
+
     return violation(node, callExpressionMessage(node));
   }
 

package/src/lexicon-schema.ts

@@ -21,6 +21,9 @@ export const IntrinsicDefSchema = z.object({
   // registration written before #1044 means. Only an explicit `true` opts a
   // call into folding. See IntrinsicDef.foldsAsCall in ../lexicon.ts.
   foldsAsCall: z.boolean().optional(),
+  // chant #1966 — same default-off shape as foldsAsCall, for the EAGER
+  // call-form opt-in. See IntrinsicDef.foldsEagerly in ../lexicon.ts.
+  foldsEagerly: z.boolean().optional(),
 });
 
 // ---------------------------------------------------------------------------

package/src/lexicon.ts

@@ -226,6 +226,29 @@ export interface IntrinsicDef {
    * run path would have called, from the module the source itself named.
    */
   readonly foldsAsCall?: boolean;
+  /**
+   * chant #1966 — opt this intrinsic's PLAIN-CALL form into EAGER folding:
+   * unlike {@link foldsAsCall}, which defers to a `{__intrinsic}` envelope
+   * revived later, `fold()` (../fold/fold.ts) calls the real function
+   * immediately, with the folded arguments, and its real return value IS the
+   * folded value.
+   *
+   * Exists for a lexicon helper whose result is commonly embedded directly in
+   * a template literal (`` `${matrix("os")}` ``, github's
+   * `matrix`/`inputs`/…) — an envelope is still a plain `{__intrinsic, args}`
+   * object when the enclosing template folds, so `String()` coercion at fold
+   * time would stringify it as `"[object Object]"` instead of the real value.
+   * Eager evaluation produces the real, already-live result instead.
+   *
+   * Same admission bar as {@link foldsAsCall} (a pure function of its
+   * arguments — no I/O, no mutable state, no dependency on anything but its
+   * arguments) and mutually exclusive with both {@link isTag} and
+   * `foldsAsCall`: a plain call folds exactly one way.
+   * `../discovery/fold-import.ts`'s `resolveActiveLexiconExport` checks this
+   * to admit the function export into `externals` at all — a lexicon
+   * package's function export is excluded there otherwise.
+   */
+  readonly foldsEagerly?: boolean;
 }
 
 /**
@@ -257,8 +280,8 @@ export interface IntrinsicDef {
  * `dist/manifest.json`) that may predate either field. `undefined` there
  * means what it always did — not a tag, not opted in.
  */
-export function intrinsicFolds(def: { isTag?: boolean; foldsAsCall?: boolean }): boolean {
-  return intrinsicTagFolds(def) || intrinsicCallFolds(def);
+export function intrinsicFolds(def: { isTag?: boolean; foldsAsCall?: boolean; foldsEagerly?: boolean }): boolean {
+  return intrinsicTagFolds(def) || intrinsicCallFolds(def) || intrinsicCallFoldsEagerly(def);
 }
 
 /** True when this intrinsic's TAGGED-TEMPLATE form folds (`Sub\`...\``) — see {@link intrinsicFolds}. */
@@ -280,6 +303,15 @@ export function intrinsicCallFolds(def: { isTag?: boolean; foldsAsCall?: boolean
   return def.isTag !== true && def.foldsAsCall === true;
 }
 
+/**
+ * True when this intrinsic's PLAIN-CALL form folds EAGERLY (chant #1966) —
+ * i.e. the lexicon opted it in via {@link IntrinsicDef.foldsEagerly}.
+ * `isTag: true` disqualifies, same as {@link intrinsicCallFolds}.
+ */
+export function intrinsicCallFoldsEagerly(def: { isTag?: boolean; foldsEagerly?: boolean }): boolean {
+  return def.isTag !== true && def.foldsEagerly === true;
+}
+
 /**
  * Options passed to a MigrationSource by `chant migrate`.
  */
@@ -406,6 +438,61 @@ export interface ComponentPipelineResult {
   jobs: ComponentPipelineJob[];
 }
 
+/**
+ * Finding-mode a scheduled Op surfaces on drift — the vocabulary the
+ * temporal-lexicon composites (`WorkflowAuditOp`/`PipelineAuditOp`/
+ * `ReconcileOp`) already declare on the Op itself (#927). The mode is baked
+ * into the Op's own activity args at build time and is never re-passed on the
+ * generated CI invocation; here it decides only what token/permission wiring
+ * the generated job needs to act on a finding — elevated write access for
+ * `issue`/`pull-request`/`merge-request`, none for `report`.
+ */
+export type OpFindingMode = "report" | "issue" | "pull-request" | "merge-request";
+
+/** One scheduled Op to generate CI for — the cron-triggered counterpart to a component (generate mode). */
+export interface ScheduledOpSpec {
+  /** Op name (`*.op.ts`'s `Op({ name })`) — what `chant run <name>` targets. */
+  name: string;
+  /** Cron expression driving the CI-native trigger — the CI-only alternative to a Temporal `TemporalSchedule`. */
+  schedule: string;
+  /** This Op's finding-mode, for permission/token wiring only (see {@link OpFindingMode}). Default: "report" — no elevated permissions. */
+  findingMode?: OpFindingMode;
+}
+
+/** One CI job generated for a scheduled Op. */
+export interface OpPipelineJob {
+  /** CI job name (safe as a YAML key). */
+  jobName: string;
+  /** The Op this job runs. */
+  op: string;
+  /** Cron expression this job's workflow is scheduled on. */
+  schedule: string;
+  /** The finding-mode wired for this job. */
+  findingMode: OpFindingMode;
+}
+
+/**
+ * One generated CI file for a scheduled Op. Unlike a component pipeline —
+ * one combined document for the whole graph — a cron trigger is
+ * workflow-scoped in every CI provider chant targets (GitHub Actions'
+ * `on.schedule`, a GitLab pipeline schedule bound to one `.gitlab-ci.yml`), so
+ * each scheduled Op gets its own file.
+ */
+export interface OpPipelineFile {
+  /** Suggested file name (e.g. `<op-name>.yml`), relative to the provider's workflow directory. */
+  name: string;
+  /** The synthesized CI YAML for this Op. */
+  yaml: string;
+}
+
+/** The synthesized CI pipeline for a set of scheduled Ops (generate mode's Op counterpart, #927). */
+export interface OpPipelineResult {
+  /** One file per scheduled Op. */
+  files: OpPipelineFile[];
+  /** Every generated job, in emit order — one per Op. */
+  jobs: OpPipelineJob[];
+}
+
 /**
  * Live status of a single deploy unit (a CloudFormation stack, a K8s release, …)
  * addressed by its deployed name — the per-component presence signal
@@ -640,6 +727,20 @@ export interface LexiconPlugin {
     options?: ComponentPipelineOptions,
   ): ComponentPipelineResult;
 
+  /**
+   * Generate CI for a set of scheduled, stateless Ops — the cron-triggered
+   * sibling of {@link generateComponentPipeline} (#927). Each
+   * `ScheduledOpSpec` becomes its own CI file (cron triggers are
+   * workflow-scoped in every CI provider chant targets), invoking `chant run
+   * <name>` on the local executor — the same one-shot invocation `chant run
+   * <op>` runs by hand. Only CI-provider lexicons (gitlab, github, forgejo)
+   * implement this; omit for lexicons that are not CI providers.
+   */
+  generateOpPipeline?(
+    ops: ScheduledOpSpec[],
+    options?: ComponentPipelineOptions,
+  ): OpPipelineResult;
+
   /**
    * Render this lexicon's config-declared build roots into entities (#1548
    * piece 3) — the seam for a build root that is NOT typed chant source. The