compile: add target + op-granularity plugin seam to StableHLO emitter

Thread an optional target id and OpGranularityPolicy through
toStableHlo -> StableHloConverterFactory -> StableHloConverter ->
ConversionContext, so per-target emission decisions (fused vs decomposed
ops = target legalization) are possible without any hardware knowledge in
the agnostic core.

OpGranularityPolicy (+ FusedOpAllowList) lives in skainet-compile-dag, the
module both the emitter (skainet-compile-hlo) and the TargetOptimizer
registry (skainet-compile-opt) already depend on, so no new dependency
edges and no cycle. TargetOptimizer gains granularity(); TargetOptimizers
gains granularityFor(target). The caller resolves the policy and passes it
in, keeping the emitter decoupled from the registry. Everything defaults to
null (decompose all), so emission is byte-identical today.

Author: michalharakal

skainet-compile/skainet-compile-dag/src/commonMain/kotlin/sk/ainet/compile/target/OpGranularityPolicy.kt

@@ -0,0 +1,35 @@
+package sk.ainet.compile.target
+
+/**
+ * Per-target policy deciding, for a **fused** graph op (by op name, e.g. "layernorm",
+ * "scaleddotproductattention"), whether an emitter should KEEP it as a single target op
+ * (`stablehlo.composite` / native kernel-call) or DECOMPOSE it into primitives.
+ *
+ * This is the seam for **target legalization** — matching the op *granularity* a fragile
+ * vendor compiler expects, without leaking any hardware knowledge into the agnostic core.
+ * The core never calls this directly; the emitters ([toStableHlo] / the C codegen) consult
+ * the policy their caller resolved for the selected target. A `null` policy means "decompose
+ * everything", which is the portable default (llvm-cpu et al.).
+ *
+ * Lives in the shared DAG module so both the StableHLO emitter (`skainet-compile-hlo`) and
+ * the `TargetOptimizer` registry (`skainet-compile-opt`) can reference it without either
+ * gaining a new dependency edge.
+ */
+public interface OpGranularityPolicy {
+    /** Backend/device id this policy applies to (matches the target string / iree device). */
+    public val target: String
+
+    /** `true` = keep [opName] fused (emit composite / kernel-call); `false` = decompose. */
+    public fun keepFused(opName: String): Boolean
+}
+
+/**
+ * Straightforward allow-list policy: an op is kept fused iff its (lower-cased) name is in
+ * [fused]. Everything else decomposes.
+ */
+public class FusedOpAllowList(
+    override val target: String,
+    private val fused: Set<String>,
+) : OpGranularityPolicy {
+    override fun keepFused(opName: String): Boolean = opName.lowercase() in fused
+}

skainet-compile/skainet-compile-hlo/src/commonMain/kotlin/sk/ainet/compile/hlo/ConversionContext.kt

@@ -23,7 +23,19 @@ public class ConversionContext @kotlin.jvm.JvmOverloads constructor(
      * See issue #523 for the architecture context.
      */
     public val materializationPolicy: ConstantMaterializationPolicy =
-        ConstantMaterializationPolicy.InlineAlways
+        ConstantMaterializationPolicy.InlineAlways,
+    /**
+     * Selected compile target (iree device id, e.g. "torq"); `null` = target-agnostic.
+     * Threaded through so per-target emit decisions (e.g. op granularity) are possible
+     * without any hardware knowledge in the shared emitter.
+     */
+    public val target: String? = null,
+    /**
+     * Per-target op-granularity policy (fused vs decomposed emission). Resolved by the
+     * caller from the [sk.ainet.compile.opt.TargetOptimizers] registry and passed in;
+     * `null` = decompose everything (portable default). The emitter only *reads* it.
+     */
+    public val granularity: sk.ainet.compile.target.OpGranularityPolicy? = null
 ) {
     private val valueNames = mutableMapOf<String, String>()
     private val valueTypes = mutableMapOf<String, String>()

skainet-compile/skainet-compile-hlo/src/commonMain/kotlin/sk/ainet/compile/hlo/StableHloConverter.kt

@@ -23,14 +23,18 @@ public class StableHloConverter @kotlin.jvm.JvmOverloads constructor(
      * through to every [ConversionContext] this converter creates.
      */
     private val materializationPolicy: ConstantMaterializationPolicy =
-        ConstantMaterializationPolicy.InlineAlways
+        ConstantMaterializationPolicy.InlineAlways,
+    /** Selected compile target (iree device id, e.g. "torq"); handed to every context. */
+    private val target: String? = null,
+    /** Per-target op-granularity policy; handed to every context (null = decompose all). */
+    private val granularity: sk.ainet.compile.target.OpGranularityPolicy? = null
 ) {
 
     /**
      * Convert a ComputeGraph to StableHLO MLIR format
      */
     public fun convert(graph: ComputeGraph, functionName: String = "main"): StableHloModule {
-        val context = ConversionContext(typeMapper, graph, materializationPolicy)
+        val context = ConversionContext(typeMapper, graph, materializationPolicy, target, granularity)
 
         // Pre-conversion validation (allow orphaned nodes for backward compatibility)
         val validationResult = graph.validate()

skainet-compile/skainet-compile-hlo/src/commonMain/kotlin/sk/ainet/compile/hlo/StableHloConverterFactory.kt

@@ -32,7 +32,9 @@ public object StableHloConverterFactory {
     @JvmStatic
     @kotlin.jvm.JvmOverloads
     public fun createBasic(
-        policy: ConstantMaterializationPolicy = ConstantMaterializationPolicy.InlineAlways
+        policy: ConstantMaterializationPolicy = ConstantMaterializationPolicy.InlineAlways,
+        target: String? = null,
+        granularity: sk.ainet.compile.target.OpGranularityPolicy? = null
     ): StableHloConverter {
         val registry = StableHloOperationRegistry()
         val typeMapper = TypeMapper()
@@ -75,7 +77,7 @@ public object StableHloConverterFactory {
         // LLM front-door op for token-id \u2192 embedding lookups.
         registry.register(GatherOperationsConverter())
 
-        return StableHloConverter(registry, typeMapper, validator, policy)
+        return StableHloConverter(registry, typeMapper, validator, policy, target, granularity)
     }
 
     /**

skainet-compile/skainet-compile-hlo/src/commonMain/kotlin/sk/ainet/compile/hlo/dag2hlo.kt

@@ -49,9 +49,23 @@ public data class StableHloModule(
  * - Currently supports: input, add, matmul, relu. Unsupported ops are emitted as comments.
  * - DType mapping expects TensorSpec.dtype to be strings like "FP32", "F32", "F64", "I32".
  */
-public fun toStableHlo(graph: ComputeGraph, functionName: String = "main"): StableHloModule {
+public fun toStableHlo(
+    graph: ComputeGraph,
+    functionName: String = "main",
+    /**
+     * Selected compile target (iree device id, e.g. "torq", "llvm-cpu"); `null` =
+     * target-agnostic emission (the portable default, unchanged behavior).
+     */
+    target: String? = null,
+    /**
+     * Per-target op-granularity policy (fused vs decomposed). Resolve it at the call
+     * site with `TargetOptimizers.granularityFor(target)` and pass it in, so the emitter
+     * stays decoupled from the optimizer registry. `null` = decompose everything.
+     */
+    granularity: sk.ainet.compile.target.OpGranularityPolicy? = null,
+): StableHloModule {
     // Use the new converter architecture
-    val converter = StableHloConverterFactory.createBasic()
+    val converter = StableHloConverterFactory.createBasic(target = target, granularity = granularity)
     return converter.convert(graph, functionName)
 }
 
@@ -78,6 +92,8 @@ public fun toStableHlo(
     graph: sk.ainet.lang.graph.ResolvedComputeGraph,
     functionName: String = "main",
     validate: Boolean = true,
+    target: String? = null,
+    granularity: sk.ainet.compile.target.OpGranularityPolicy? = null,
 ): StableHloModule {
     if (validate) {
         graph.validate().requireValid()
@@ -86,7 +102,7 @@ public fun toStableHlo(
     // for graphs that pass validation. Future versions can branch here to
     // consume `graph.resolvedLayout(edgeId)` / `graph.backendAssignment(nodeId)`
     // once those passes ship.
-    return toStableHlo(graph.delegate, functionName)
+    return toStableHlo(graph.delegate, functionName, target, granularity)
 }
 
 /**

skainet-compile/skainet-compile-opt/src/commonMain/kotlin/sk/ainet/compile/opt/TargetOptimization.kt

@@ -26,6 +26,14 @@ public interface TargetOptimizer {
     /** DAG-phase graph rewrites (produce standard, still-portable ops). */
     public fun dagPasses(): List<GraphOptimizationPass> = emptyList()
 
+    /**
+     * Op-granularity policy for the emitters (fused vs decomposed). `null` = decompose
+     * everything (the portable default). A target that wants a fused op kept as a single
+     * `stablehlo.composite` / kernel-call returns a policy here. See
+     * [sk.ainet.compile.target.OpGranularityPolicy].
+     */
+    public fun granularity(): sk.ainet.compile.target.OpGranularityPolicy? = null
+
     // Future phases keep the same shape, e.g.:
     //   public fun tapePasses(): List<TapePass> = emptyList()
     //   public fun stableHloPasses(): List<StableHloPass> = emptyList()
@@ -59,6 +67,15 @@ public object TargetOptimizers {
     public fun forTarget(target: String?): List<TargetOptimizer> =
         target?.let { registry[it]?.toList() } ?: emptyList()
 
+    /**
+     * The op-granularity policy for [target] — the first non-null [TargetOptimizer.granularity]
+     * among the registered optimizers, or `null` (decompose everything) if none provide one.
+     * Callers (the model-build tool) resolve this and pass it into `toStableHlo(...)`, so the
+     * emitter stays decoupled from this registry.
+     */
+    public fun granularityFor(target: String?): sk.ainet.compile.target.OpGranularityPolicy? =
+        forTarget(target).firstNotNullOfOrNull { it.granularity() }
+
     /** Test/reset hook. */
     public fun clear(): Unit = registry.clear()
 }