@kontourai/flow-agents 2.2.0 → 2.4.0

package/evals/integration/test_actor_identity.sh

@@ -0,0 +1,254 @@
+#!/usr/bin/env bash
+# test_actor_identity.sh - unit-style eval for the shared actor-identity resolver
+# (scripts/hooks/lib/actor-identity.js). Written against the frozen interface documented
+# in .kontourai/flow-agents/kontourai-flow-agents-287/kontourai-flow-agents-287--plan-work.md
+# Wave 1 Task 1.1 (detectRuntime/runtimeSessionId/ancestorActorSeed/sanitizeSegment/
+# serializeActor/resolveActor).
+set -uo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+MODULE="$ROOT/scripts/hooks/lib/actor-identity.js"
+
+errors=0
+
+_pass() { echo "  ✓ $1"; }
+_fail() { echo "  ✗ $1"; errors=$((errors + 1)); }
+
+if [[ ! -f "$MODULE" ]]; then
+  echo "actor identity eval skipped: $MODULE does not exist yet." >&2
+  exit 1
+fi
+
+# 1. serializeActor never contains "::" or a raw ":" inside any single segment, even given
+#    adversarial input (session_id containing ":", "/", spaces, unicode).
+if node - "$MODULE" <<'NODE'
+const path = process.argv[2];
+const { serializeActor } = require(path);
+const out = serializeActor({
+  runtime: "claude-code",
+  session_id: "sess:with/slash space:moreéé",
+  host: "ho:st/name",
+  human: "hu man:name",
+});
+if (typeof out !== "string" || out.length === 0) {
+  throw new Error(`serializeActor did not return a non-empty string: ${JSON.stringify(out)}`);
+}
+if (out.includes("::")) {
+  throw new Error(`serializeActor output contains "::": ${JSON.stringify(out)}`);
+}
+if (!/^[A-Za-z0-9_.:-]+$/.test(out)) {
+  throw new Error(`serializeActor output contains disallowed characters: ${JSON.stringify(out)}`);
+}
+NODE
+then
+  _pass "serializeActor sanitizes adversarial segments (no :: and no raw : inside a segment)"
+else
+  _fail "serializeActor did not sanitize adversarial input safely"
+fi
+
+# 2. resolveActor({FLOW_AGENTS_ACTOR: "my-actor"}) returns {actor: "my-actor", ...} — explicit
+#    override always wins, even if a runtime var is also present in the injected env.
+if node - "$MODULE" <<'NODE'
+const path = process.argv[2];
+const { resolveActor } = require(path);
+const out = resolveActor({ FLOW_AGENTS_ACTOR: "my-actor", CLAUDE_CODE_SESSION_ID: "sess-should-be-ignored" });
+if (!out || out.actor !== "my-actor") {
+  throw new Error(`resolveActor did not honor explicit FLOW_AGENTS_ACTOR override: ${JSON.stringify(out)}`);
+}
+NODE
+then
+  _pass "resolveActor honors explicit FLOW_AGENTS_ACTOR override even with a runtime var present"
+else
+  _fail "resolveActor did not honor explicit FLOW_AGENTS_ACTOR override"
+fi
+
+# 3. resolveActor({FLOW_AGENTS_ACTOR: "local"}) does NOT honor the literal "local" override
+#    (falls through to runtime/ancestry resolution) — proves "local" can never round-trip back
+#    in via the override seam.
+if node - "$MODULE" <<'NODE'
+const path = process.argv[2];
+const { resolveActor } = require(path);
+const out = resolveActor({ FLOW_AGENTS_ACTOR: "local" });
+if (!out || typeof out.actor !== "string" || out.actor.trim().toLowerCase() === "local") {
+  throw new Error(`resolveActor honored the literal "local" override: ${JSON.stringify(out)}`);
+}
+NODE
+then
+  _pass "resolveActor never honors the literal \"local\" override"
+else
+  _fail "resolveActor incorrectly honored the literal \"local\" override"
+fi
+
+# 4. resolveActor({CLAUDE_CODE_SESSION_ID: "sess-a"}) vs resolveActor({CLAUDE_CODE_SESSION_ID:
+#    "sess-b"}) (host held constant) produce two different serialized actors.
+if node - "$MODULE" <<'NODE'
+const path = process.argv[2];
+const { resolveActor } = require(path);
+const a = resolveActor({ CLAUDE_CODE_SESSION_ID: "sess-a" });
+const b = resolveActor({ CLAUDE_CODE_SESSION_ID: "sess-b" });
+if (!a || !b || !a.actor || !b.actor) {
+  throw new Error(`resolveActor returned an empty actor for a runtime-native session id: a=${JSON.stringify(a)} b=${JSON.stringify(b)}`);
+}
+if (a.actor === b.actor) {
+  throw new Error(`resolveActor produced the same actor for two distinct session ids: ${JSON.stringify(a)} vs ${JSON.stringify(b)}`);
+}
+NODE
+then
+  _pass "resolveActor produces distinct actors for distinct runtime session ids"
+else
+  _fail "resolveActor did not distinguish between distinct runtime session ids"
+fi
+
+# 5. Stability test: call resolveActor({}) (real ambient env, no runtime var, forcing the
+#    ancestry path) twice in the same process with a real setTimeout gap of several seconds
+#    between calls; assert byte-identical output both times.
+if node - "$MODULE" <<'NODE'
+const path = process.argv[2];
+const { resolveActor } = require(path);
+const first = resolveActor({});
+setTimeout(() => {
+  const second = resolveActor({});
+  const a = JSON.stringify(first);
+  const b = JSON.stringify(second);
+  if (a !== b) {
+    console.error(`resolveActor({}) was not stable across a delay: first=${a} second=${b}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}, 3000);
+NODE
+then
+  _pass "resolveActor({}) is byte-identical across a several-second real-time gap (ancestry stability)"
+else
+  _fail "resolveActor({}) was not stable across a several-second real-time gap"
+fi
+
+# 6. resolveActor({FLOW_AGENTS_ACTOR_TEST_FORCE_UNRESOLVED: "1", NODE_ENV: "test"}) returns
+#    {actor: "", source: "test-forced-unresolved"} — the hatch requires BOTH the force-unresolved
+#    var AND NODE_ENV=test (F4, #287 fix iteration 1); the var alone (no NODE_ENV=test) must NOT
+#    trip the hatch, proving it cannot be tripped by an accidental/malicious env var outside a
+#    real test harness.
+if node - "$MODULE" <<'NODE'
+const path = process.argv[2];
+const { resolveActor } = require(path);
+const out = resolveActor({ FLOW_AGENTS_ACTOR_TEST_FORCE_UNRESOLVED: "1", NODE_ENV: "test" });
+if (!out || out.actor !== "" || out.source !== "test-forced-unresolved") {
+  throw new Error(`resolveActor did not honor the test-forced-unresolved escape hatch: ${JSON.stringify(out)}`);
+}
+NODE
+then
+  _pass "resolveActor honors FLOW_AGENTS_ACTOR_TEST_FORCE_UNRESOLVED escape hatch when NODE_ENV=test is also set"
+else
+  _fail "resolveActor did not honor FLOW_AGENTS_ACTOR_TEST_FORCE_UNRESOLVED escape hatch with NODE_ENV=test"
+fi
+
+# 6b (F4 negative). The hatch var alone, WITHOUT NODE_ENV=test, must NOT force an unresolved actor
+# — proves the gate is a real AND, not an OR.
+if node - "$MODULE" <<'NODE'
+const path = process.argv[2];
+const { resolveActor } = require(path);
+const out = resolveActor({ FLOW_AGENTS_ACTOR_TEST_FORCE_UNRESOLVED: "1" });
+if (out && out.source === "test-forced-unresolved") {
+  throw new Error(`resolveActor honored the test-forced-unresolved escape hatch without NODE_ENV=test: ${JSON.stringify(out)}`);
+}
+NODE
+then
+  _pass "resolveActor does NOT honor the escape hatch when NODE_ENV=test is missing (F4 gate is AND, not OR)"
+else
+  _fail "resolveActor incorrectly honored the escape hatch without NODE_ENV=test"
+fi
+
+# 7 (T1, F2). Adversarial FLOW_AGENTS_ACTOR override — containing "::", a raw newline, and
+# exceeding 64 chars — resolves to a sanitized, capped actor: no ":" anywhere, length <= 64.
+if node - "$MODULE" <<'NODE'
+const path = process.argv[2];
+const { resolveActor } = require(path);
+const adversarial = "a::b\nc" + "x".repeat(100);
+const out = resolveActor({ FLOW_AGENTS_ACTOR: adversarial });
+if (!out || typeof out.actor !== "string" || !out.actor) {
+  throw new Error(`resolveActor returned no actor for adversarial override: ${JSON.stringify(out)}`);
+}
+if (out.actor.includes(":")) {
+  throw new Error(`resolveActor did not strip ":" from adversarial override: ${JSON.stringify(out)}`);
+}
+if (out.actor.includes("\n")) {
+  throw new Error(`resolveActor did not strip newline from adversarial override: ${JSON.stringify(out)}`);
+}
+if (out.actor.length > 64) {
+  throw new Error(`resolveActor did not cap adversarial override at 64 chars: ${JSON.stringify(out)}`);
+}
+NODE
+then
+  _pass "resolveActor sanitizes and caps an adversarial FLOW_AGENTS_ACTOR override (:: / newline / >64 chars)"
+else
+  _fail "resolveActor did not sanitize/cap an adversarial FLOW_AGENTS_ACTOR override"
+fi
+
+# 8 (T1, F3). Rejected FLOW_AGENTS_ACTOR=local (case-insensitive) emits exactly one stderr warning
+# line naming FLOW_AGENTS_ACTOR — never on stdout, never a thrown exception.
+TMPDIR_EVAL_STDERR_CAPTURE="$(mktemp)"
+if node - "$MODULE" >"$TMPDIR_EVAL_STDERR_CAPTURE.out" 2>"$TMPDIR_EVAL_STDERR_CAPTURE.err" <<'NODE'
+const path = process.argv[2];
+const { resolveActor } = require(path);
+const out = resolveActor({ FLOW_AGENTS_ACTOR: "LOCAL" });
+process.stdout.write(JSON.stringify(out));
+NODE
+then
+  if grep -qF "FLOW_AGENTS_ACTOR=local" "$TMPDIR_EVAL_STDERR_CAPTURE.err" \
+    && ! grep -qF "FLOW_AGENTS_ACTOR=local" "$TMPDIR_EVAL_STDERR_CAPTURE.out"; then
+    _pass "rejected FLOW_AGENTS_ACTOR=local (case-insensitive) emits one stderr warning, never on stdout"
+  else
+    _fail "rejected FLOW_AGENTS_ACTOR=local warning missing from stderr or leaked onto stdout: out=$(cat "$TMPDIR_EVAL_STDERR_CAPTURE.out") err=$(cat "$TMPDIR_EVAL_STDERR_CAPTURE.err")"
+  fi
+else
+  _fail "resolveActor threw for a rejected FLOW_AGENTS_ACTOR=local override (must never throw)"
+fi
+rm -f "$TMPDIR_EVAL_STDERR_CAPTURE.out" "$TMPDIR_EVAL_STDERR_CAPTURE.err"
+
+# 9 (T4, F7). resolveActor({FLOW_AGENTS_ACTOR: ":::"}) — a value that strips to empty under the
+# allowed [A-Za-z0-9_.-] charset — must NOT adopt the shared "unknown" sentinel: it falls through
+# to derivation (source != "explicit-override", actor != "unknown") and emits one stderr warning,
+# never stdout, never a thrown exception.
+TMPDIR_EVAL_STRIPEMPTY_CAPTURE="$(mktemp)"
+if node - "$MODULE" >"$TMPDIR_EVAL_STRIPEMPTY_CAPTURE.out" 2>"$TMPDIR_EVAL_STRIPEMPTY_CAPTURE.err" <<'NODE'
+const path = process.argv[2];
+const { resolveActor } = require(path);
+const out = resolveActor({ FLOW_AGENTS_ACTOR: ":::" });
+process.stdout.write(JSON.stringify(out));
+NODE
+then
+  STRIPEMPTY_OUT="$(cat "$TMPDIR_EVAL_STRIPEMPTY_CAPTURE.out")"
+  if echo "$STRIPEMPTY_OUT" | node -e 'const out = JSON.parse(require("fs").readFileSync(0, "utf8")); if (!out || out.actor === "unknown" || out.source === "explicit-override") process.exit(1);'     && grep -qF "FLOW_AGENTS_ACTOR" "$TMPDIR_EVAL_STRIPEMPTY_CAPTURE.err"     && ! grep -qF "FLOW_AGENTS_ACTOR" "$TMPDIR_EVAL_STRIPEMPTY_CAPTURE.out"; then
+    _pass "resolveActor({FLOW_AGENTS_ACTOR: ':::'}) falls through to a derived actor (not 'unknown', not explicit-override) with a stderr warning"
+  else
+    _fail "resolveActor did not fall through correctly for a strip-to-empty override: out=$STRIPEMPTY_OUT err=$(cat "$TMPDIR_EVAL_STRIPEMPTY_CAPTURE.err")"
+  fi
+else
+  _fail "resolveActor threw for a strip-to-empty FLOW_AGENTS_ACTOR override (must never throw)"
+fi
+rm -f "$TMPDIR_EVAL_STRIPEMPTY_CAPTURE.out" "$TMPDIR_EVAL_STRIPEMPTY_CAPTURE.err"
+
+# 10 (T4, F7). resolveActor({FLOW_AGENTS_ACTOR: "unknown"}) — a deliberate literal "unknown" — is
+# honored as-is via the explicit-override path (proves the sentinel itself is not blacklisted;
+# only a strip-to-empty value is rejected).
+if node - "$MODULE" <<'NODE'
+const path = process.argv[2];
+const { resolveActor } = require(path);
+const out = resolveActor({ FLOW_AGENTS_ACTOR: "unknown" });
+if (!out || out.actor !== "unknown" || out.source !== "explicit-override") {
+  throw new Error(`resolveActor did not honor a deliberate literal "unknown" override: ${JSON.stringify(out)}`);
+}
+NODE
+then
+  _pass "resolveActor honors a deliberate literal FLOW_AGENTS_ACTOR=unknown override (sentinel itself is not blacklisted)"
+else
+  _fail "resolveActor did not honor a deliberate literal FLOW_AGENTS_ACTOR=unknown override"
+fi
+
+if [[ "$errors" -eq 0 ]]; then
+  echo "Actor identity resolver integration passed."
+  exit 0
+fi
+
+echo "Actor identity resolver integration failed: $errors issue(s)."
+exit 1

package/evals/integration/test_builder_step_producers.sh

@@ -15,8 +15,8 @@
 #   5. builder.learn.decisions               (step: learn,        expectation: decision-evidence)
 #   6. builder.learn.evidence                (step: learn,        expectation: learning-evidence)
 #
-# build.flow.json confirmation:
-#   - All 6 claims above are required:true.
+# Flow Definition confirmation:
+#   - All 6 claims above are required:true across builder.build and builder.publish-learn.
 #   - policy-compliance remains required:false (advisory — no skill producer).
 #
 # Deterministic, no model spend, self-cleaning.
@@ -106,21 +106,21 @@ setup_tamper_session() {
   local t_dir="$1" slug="$2" step="$3"
   mkdir -p "$t_dir"
   printf '# Repo\n' > "$t_dir/AGENTS.md"
-  mkdir -p "$t_dir/.flow-agents/$slug"
+  mkdir -p "$t_dir/.kontourai/flow-agents/$slug"
 
   flow_agents_node "workflow-sidecar" ensure-session \
-    --artifact-root "$t_dir/.flow-agents" \
+    --artifact-root "$t_dir/.kontourai/flow-agents" \
     --task-slug "$slug" \
     --title "Tamper test: $step" \
     --summary "Testing tamper detection." \
     --flow-id builder.build \
     --timestamp "2026-06-26T00:00:00Z" >/dev/null 2>&1
 
-  flow_agents_node "workflow-sidecar" init-plan "$t_dir/.flow-agents/$slug/$slug--deliver.md" \
+  flow_agents_node "workflow-sidecar" init-plan "$t_dir/.kontourai/flow-agents/$slug/$slug--deliver.md" \
     --source-request "Test" --summary "Testing" \
     --timestamp "2026-06-26T00:00:00Z" >/dev/null 2>&1
 
-  set_active_step "$t_dir/.flow-agents" "$slug" "$step"
+  set_active_step "$t_dir/.kontourai/flow-agents" "$slug" "$step"
 }
 
 # ─── Test: produce a gate claim at a given step ───────────────────────────────
@@ -178,12 +178,12 @@ test_tamper_blocks() {
   setup_tamper_session "$t_dir" "$slug" "$step"
 
   # Write a TAMPERED trust.bundle: stored verified, evidence passing=false
-  python3 - "$t_dir/.flow-agents/$slug/trust.bundle" "$claim_type" "$subject_type" << 'PY'
+  python3 - "$t_dir/.kontourai/flow-agents/$slug/trust.bundle" "$claim_type" "$subject_type" << 'PY'
 import json, sys
 claim_type = sys.argv[2]
 subject_type = sys.argv[3]
 bundle = {
-    "schemaVersion": 3,
+    "schemaVersion": 5,
     "source": "flow-agents/workflow-sidecar",
     "claims": [{
         "id": "c1",
@@ -254,13 +254,16 @@ PY
   fi
 }
 
-# ─── Test 0: build.flow.json required:true confirmation ──────────────────────
+# ─── Test 0: Flow Definition required:true confirmation ──────────────────────
 echo ""
-echo "=== 0. build.flow.json: confirm required:true for produced gates ==="
+echo "=== 0. Flow Definitions: confirm required:true for produced gates ==="
 
 node -e "
   const fs = require('fs');
-  const flow = JSON.parse(fs.readFileSync('$ROOT/kits/builder/flows/build.flow.json', 'utf8'));
+  const flows = [
+    JSON.parse(fs.readFileSync('$ROOT/kits/builder/flows/build.flow.json', 'utf8')),
+    JSON.parse(fs.readFileSync('$ROOT/kits/builder/flows/publish-learn.flow.json', 'utf8')),
+  ];
   const requiredTrue = [
     'selected-work',
     'pickup-probe-readiness',
@@ -271,26 +274,31 @@ node -e "
   ];
   const requiredFalse = ['policy-compliance'];
   let ok = true;
-  for (const [gateName, gate] of Object.entries(flow.gates)) {
-    for (const exp of gate.expects || []) {
+  for (const flow of flows) {
+    for (const [gateName, gate] of Object.entries(flow.gates || {})) {
+      for (const exp of gate.expects || []) {
       if (requiredTrue.includes(exp.id) && exp.required !== true) {
-        console.error('FAIL: ' + exp.id + ' in ' + gateName + ' should be required:true, got ' + exp.required);
+        console.error('FAIL: ' + exp.id + ' in ' + flow.id + '/' + gateName + ' should be required:true, got ' + exp.required);
         ok = false;
       }
       if (requiredFalse.includes(exp.id) && exp.required !== false) {
-        console.error('FAIL: ' + exp.id + ' in ' + gateName + ' should remain required:false (advisory), got ' + exp.required);
+        console.error('FAIL: ' + exp.id + ' in ' + flow.id + '/' + gateName + ' should remain required:false (advisory), got ' + exp.required);
         ok = false;
       }
+      }
     }
   }
   if (!ok) process.exit(1);
 " 2>/dev/null \
-  && _pass "build.flow.json: 6 produced gates are required:true, policy-compliance is required:false" \
-  || _fail "build.flow.json: required flag mismatch"
+  && _pass "Flow Definitions: 6 produced gates are required:true, policy-compliance is required:false" \
+  || _fail "Flow Definitions: required flag mismatch"
 
 node -e "
   const fs = require('fs');
-  const flow = JSON.parse(fs.readFileSync('$ROOT/kits/builder/flows/build.flow.json', 'utf8'));
+  const flows = [
+    JSON.parse(fs.readFileSync('$ROOT/kits/builder/flows/build.flow.json', 'utf8')),
+    JSON.parse(fs.readFileSync('$ROOT/kits/builder/flows/publish-learn.flow.json', 'utf8')),
+  ];
   const producedIds = [
     'selected-work',
     'pickup-probe-readiness',
@@ -300,18 +308,20 @@ node -e "
     'learning-evidence',
   ];
   let ok = true;
-  for (const [gateName, gate] of Object.entries(flow.gates)) {
-    for (const exp of gate.expects || []) {
+  for (const flow of flows) {
+    for (const [gateName, gate] of Object.entries(flow.gates || {})) {
+      for (const exp of gate.expects || []) {
       if (producedIds.includes(exp.id) && exp.explore_hint) {
-        console.error('FAIL: ' + exp.id + ' in ' + gateName + ' still has explore_hint (remove when producer exists)');
+        console.error('FAIL: ' + exp.id + ' in ' + flow.id + '/' + gateName + ' still has explore_hint (remove when producer exists)');
         ok = false;
       }
+      }
     }
   }
   if (!ok) process.exit(1);
 " 2>/dev/null \
-  && _pass "build.flow.json: no explore_hint on produced gate entries" \
-  || _fail "build.flow.json: produced gate entries still have explore_hint"
+  && _pass "Flow Definitions: no explore_hint on produced gate entries" \
+  || _fail "Flow Definitions: produced gate entries still have explore_hint"
 
 # ─── Tests 1–6: produce + tamper-block for each of the 6 claims ──────────────
 

package/evals/integration/test_bundle_install.sh

@@ -158,13 +158,17 @@ echo "--- Installed Layout ---"
 for dir in \
   "$KIRO_DEST/agents" \
   "$BASE_DEST/.flow-agents" \
+  "$BASE_DEST/.kontourai/flow-agents" \
   "$CLAUDE_DEST/.claude/agents" \
   "$CLAUDE_DEST/.claude/skills" \
   "$CLAUDE_DEST/.flow-agents" \
+  "$CLAUDE_DEST/.kontourai/flow-agents" \
   "$CODEX_DEST/.codex/agents" \
   "$CODEX_DEST/.codex/skills" \
   "$CODEX_DEST/.flow-agents" \
-  "$CODEX_FULL_DEST/.flow-agents"; do
+  "$CODEX_DEST/.kontourai/flow-agents" \
+  "$CODEX_FULL_DEST/.flow-agents" \
+  "$CODEX_FULL_DEST/.kontourai/flow-agents"; do
   if [[ -d "$dir" ]]; then
     _pass "$dir exists"
   else
@@ -218,7 +222,7 @@ fi
 
 if rg -F -q "console_telemetry_url=$LOCAL_KONTOUR_CONSOLE_URL" "$CODEX_INIT_DEST/scripts/telemetry/telemetry.conf" \
   && rg -q '^console_tenant_id=tenant-a$' "$CODEX_INIT_DEST/scripts/telemetry/telemetry.conf" \
-  && [[ -f "$CODEX_INIT_DEST/.flow-agents/runtime/codex/activation.json" ]]; then
+  && [[ -f "$CODEX_INIT_DEST/.kontourai/flow-agents/projections/codex/activation.json" ]]; then
   _pass "flow-agents init persists Console config and activates Codex kits"
 else
   _fail "flow-agents init did not persist Console config or activate Codex kits"
@@ -226,6 +230,7 @@ fi
 
 if [[ -f "$BASE_INIT_DEST/AGENTS.md" ]] \
   && [[ -d "$BASE_INIT_DEST/.flow-agents" ]] \
+  && [[ -d "$BASE_INIT_DEST/.kontourai/flow-agents" ]] \
   && rg -F -q "console_telemetry_url=$LOCAL_KONTOUR_CONSOLE_URL" "$BASE_INIT_DEST/scripts/telemetry/telemetry.conf"; then
   _pass "flow-agents init default installs base AGENTS.md workspace contract"
 else
@@ -287,7 +292,7 @@ NODE
   else
     _fail "$dir is missing Kit Catalog or Builder Kit manifest"
   fi
-  if [[ -f "$dir/kits/builder/flows/shape.flow.json" && -f "$dir/kits/builder/flows/build.flow.json" ]]; then
+  if [[ -f "$dir/kits/builder/flows/shape.flow.json" && -f "$dir/kits/builder/flows/build.flow.json" && -f "$dir/kits/builder/flows/publish-learn.flow.json" ]]; then
     _pass "$dir includes Builder Kit Flow Definitions"
   else
     _fail "$dir is missing Builder Kit Flow Definitions"
@@ -316,13 +321,13 @@ const dest = process.argv[2];
 const data = JSON.parse(fs.readFileSync(process.argv[3], "utf8"));
 if (data.selected_adapter !== "codex-local") throw new Error("codex-local was not selected");
 const ids = new Set((data.generated_runtime_files || []).map((item) => item.asset_id));
-for (const expected of ["builder.shape", "builder.build", "codex-local.activation"]) {
+for (const expected of ["builder.shape", "builder.build", "builder.publish-learn", "codex-local.activation"]) {
   if (!ids.has(expected)) throw new Error(`missing generated runtime asset: ${expected}`);
 }
 for (const item of data.generated_runtime_files || []) {
   if (!fs.existsSync(path.join(dest, item.path))) throw new Error(`generated runtime file missing: ${item.path}`);
 }
-if (!fs.existsSync(path.join(dest, ".flow-agents/runtime/codex/activation.json"))) throw new Error("runtime activation manifest missing");
+if (!fs.existsSync(path.join(dest, ".kontourai/flow-agents/projections/codex/activation.json"))) throw new Error("runtime activation manifest missing");
 console.log("ok");
 NODE
 then
@@ -335,7 +340,7 @@ if node - "$KIRO_DEST" "$BASE_DEST" "$CLAUDE_DEST" "$CODEX_DEST" <<'NODE'
 const fs = require("node:fs");
 const path = require("node:path");
 for (const root of process.argv.slice(2)) {
-  for (const rel of ["kits/catalog.json", "kits/builder/kit.json", "kits/builder/flows/shape.flow.json", "kits/builder/flows/build.flow.json"]) {
+  for (const rel of ["kits/catalog.json", "kits/builder/kit.json", "kits/builder/flows/shape.flow.json", "kits/builder/flows/build.flow.json", "kits/builder/flows/publish-learn.flow.json"]) {
     JSON.parse(fs.readFileSync(path.join(root, rel), "utf8"));
   }
 }
@@ -367,25 +372,25 @@ else
   _pass "installed bundles are free of machine-local absolute paths"
 fi
 
-if [[ -f "$CLAUDE_DEST/.flow-agents/.gitkeep" ]]; then
+if [[ -f "$CLAUDE_DEST/.kontourai/flow-agents/.gitkeep" ]]; then
   _pass "Claude Code task dir scaffold installed"
 else
   _fail "Claude Code task dir scaffold missing"
 fi
 
-if [[ -f "$CODEX_DEST/.flow-agents/.gitkeep" ]]; then
+if [[ -f "$CODEX_DEST/.kontourai/flow-agents/.gitkeep" ]]; then
   _pass "Codex task dir scaffold installed"
 else
   _fail "Codex task dir scaffold missing"
 fi
 
-if [[ -f "$OPENCODE_DEST/.flow-agents/.gitkeep" ]]; then
+if [[ -f "$OPENCODE_DEST/.kontourai/flow-agents/.gitkeep" ]]; then
   _pass "opencode task dir scaffold installed"
 else
   _fail "opencode task dir scaffold missing"
 fi
 
-if [[ -f "$PI_DEST/.flow-agents/.gitkeep" ]]; then
+if [[ -f "$PI_DEST/.kontourai/flow-agents/.gitkeep" ]]; then
   _pass "pi task dir scaffold installed"
 else
   _fail "pi task dir scaffold missing"
@@ -417,9 +422,10 @@ else
   _fail "installed Claude permissions/statusline or Codex profile-v2 progress config is missing"
 fi
 
-if [[ -f "$CODEX_DEST/.codex/kdev.config.toml" && -f "$CODEX_DEST/.codex/kdev-br.config.toml" ]] \
-  && rg -q 'approvals_reviewer = "auto_review"' "$CODEX_DEST/.codex/kdev.config.toml" \
-  && rg -q 'model_provider = "amazon-bedrock"' "$CODEX_DEST/.codex/kdev-br.config.toml"; then
+if [[ -f "$CODEX_DEST/.codex/builder.config.toml" && -f "$CODEX_DEST/.codex/personal.config.toml" ]] \
+  && [[ "$(find "$CODEX_DEST/.codex" -maxdepth 1 -name '*.config.toml' | wc -l | tr -d ' ')" == "2" ]] \
+  && rg -q 'Flow Agents Builder mode' "$CODEX_DEST/.codex/builder.config.toml" \
+  && rg -q 'knowledge-capture' "$CODEX_DEST/.codex/personal.config.toml"; then
   _pass "Codex install includes profile-v2 config files"
 else
   _fail "Codex install is missing profile-v2 config files"
@@ -517,7 +523,7 @@ const critique = {
   }],
 };
 function writeFixture(root) {
-  const taskDir = path.join(root, ".flow-agents/installed-hook-demo");
+  const taskDir = path.join(root, ".kontourai/flow-agents/installed-hook-demo");
   fs.mkdirSync(taskDir, { recursive: true });
   fs.writeFileSync(path.join(taskDir, "state.json"), JSON.stringify(state), "utf8");
   fs.writeFileSync(path.join(taskDir, "critique.json"), JSON.stringify(critique), "utf8");
@@ -593,7 +599,7 @@ const critique = {
   critiques: [{ id: "oc-review", reviewer: "tool-code-reviewer", reviewed_at: "2026-06-01T00:01:00Z", verdict: "fail", summary: "Blocking.", findings: [{ id: "oc-open", severity: "high", status: "open", description: "Open finding." }] }],
 };
 function writeFixture(root) {
-  const taskDir = path.join(root, ".flow-agents/opencode-hook-demo");
+  const taskDir = path.join(root, ".kontourai/flow-agents/opencode-hook-demo");
   fs.mkdirSync(taskDir, { recursive: true });
   fs.writeFileSync(path.join(taskDir, "state.json"), JSON.stringify(state), "utf8");
   fs.writeFileSync(path.join(taskDir, "critique.json"), JSON.stringify(critique), "utf8");
@@ -652,7 +658,7 @@ const critique = {
   critiques: [{ id: "pi-review", reviewer: "tool-code-reviewer", reviewed_at: "2026-06-01T00:01:00Z", verdict: "fail", summary: "Blocking.", findings: [{ id: "pi-open", severity: "high", status: "open", description: "Open finding." }] }],
 };
 function writeFixture(root) {
-  const taskDir = path.join(root, ".flow-agents/pi-hook-demo");
+  const taskDir = path.join(root, ".kontourai/flow-agents/pi-hook-demo");
   fs.mkdirSync(taskDir, { recursive: true });
   fs.writeFileSync(path.join(taskDir, "state.json"), JSON.stringify(state), "utf8");
   fs.writeFileSync(path.join(taskDir, "critique.json"), JSON.stringify(critique), "utf8");

package/evals/integration/test_bundle_lifecycle.sh

@@ -231,18 +231,18 @@ OPENCODE_USER="$TMPDIR_EVAL/user-opencode"
 # Create user-owned files (unknown to the bundle)
 mkdir -p "$CLAUDE_USER/.claude/custom"
 echo "# user custom agent" > "$CLAUDE_USER/.claude/custom/my-custom-agent.md"
-mkdir -p "$CLAUDE_USER/.flow-agents/my-session"
-echo '{"custom":"data"}' > "$CLAUDE_USER/.flow-agents/my-session/state.json"
+mkdir -p "$CLAUDE_USER/.kontourai/flow-agents/my-session"
+echo '{"custom":"data"}' > "$CLAUDE_USER/.kontourai/flow-agents/my-session/state.json"
 
 mkdir -p "$CODEX_USER/.codex/custom"
 printf 'name = "my-custom-agent"\n' > "$CODEX_USER/.codex/custom/my-custom-agent.toml"
-mkdir -p "$CODEX_USER/.flow-agents/my-session"
-echo '{"custom":"data"}' > "$CODEX_USER/.flow-agents/my-session/state.json"
+mkdir -p "$CODEX_USER/.kontourai/flow-agents/my-session"
+echo '{"custom":"data"}' > "$CODEX_USER/.kontourai/flow-agents/my-session/state.json"
 
 mkdir -p "$OPENCODE_USER/.opencode/custom"
 echo "# user custom agent" > "$OPENCODE_USER/.opencode/custom/my-custom-agent.md"
-mkdir -p "$OPENCODE_USER/.flow-agents/my-session"
-echo '{"custom":"data"}' > "$OPENCODE_USER/.flow-agents/my-session/state.json"
+mkdir -p "$OPENCODE_USER/.kontourai/flow-agents/my-session"
+echo '{"custom":"data"}' > "$OPENCODE_USER/.kontourai/flow-agents/my-session/state.json"
 
 # Modify an installed skill file to simulate user edits
 CLAUDE_INSTALLED_SKILL="$CLAUDE_USER/.claude/skills/plan-work/SKILL.md"
@@ -272,19 +272,19 @@ fi
 (cd "$ROOT_DIR/dist/opencode" && bash install.sh "$OPENCODE_USER" >/dev/null 2>&1) || true
 
 # Assert: user-owned unknown files survive
-if [[ -f "$CLAUDE_USER/.claude/custom/my-custom-agent.md" && -f "$CLAUDE_USER/.flow-agents/my-session/state.json" ]]; then
+if [[ -f "$CLAUDE_USER/.claude/custom/my-custom-agent.md" && -f "$CLAUDE_USER/.kontourai/flow-agents/my-session/state.json" ]]; then
   _pass "claude-code re-install: user-owned files not removed by rsync"
 else
   _fail "claude-code re-install: user-owned files were removed"
 fi
 
-if [[ -f "$CODEX_USER/.codex/custom/my-custom-agent.toml" && -f "$CODEX_USER/.flow-agents/my-session/state.json" ]]; then
+if [[ -f "$CODEX_USER/.codex/custom/my-custom-agent.toml" && -f "$CODEX_USER/.kontourai/flow-agents/my-session/state.json" ]]; then
   _pass "codex re-install: user-owned files not removed by rsync"
 else
   _fail "codex re-install: user-owned files were removed"
 fi
 
-if [[ -f "$OPENCODE_USER/.opencode/custom/my-custom-agent.md" && -f "$OPENCODE_USER/.flow-agents/my-session/state.json" ]]; then
+if [[ -f "$OPENCODE_USER/.opencode/custom/my-custom-agent.md" && -f "$OPENCODE_USER/.kontourai/flow-agents/my-session/state.json" ]]; then
   _pass "opencode re-install: user-owned files not removed by rsync"
 else
   _fail "opencode re-install: user-owned files were removed"
@@ -528,7 +528,7 @@ fi
 # and point CLAUDE_PROJECT_DIR there so the hook can resolve its scripts.
 # This mirrors the real dogfood use case where the repo root has scripts/ from the bundle.
 DOGFOOD_WORKSPACE="$CLAUDE_IDEM"  # reuse the installed workspace from the idempotent section
-mkdir -p "$DOGFOOD_WORKSPACE/.flow-agents"
+mkdir -p "$DOGFOOD_WORKSPACE/.kontourai/flow-agents"
 
 if node - "$DOGFOOD_DEST2/.claude/settings.json" "$DOGFOOD_WORKSPACE" << 'NODE'
 const fs = require("node:fs");
@@ -537,7 +537,7 @@ const { spawnSync } = require("node:child_process");
 const [settingsPath, workspace] = process.argv.slice(2);
 
 // Write minimal fixtures for workflow-steering into the workspace
-const taskDir = path.join(workspace, ".flow-agents", "dogfood-hook-demo");
+const taskDir = path.join(workspace, ".kontourai", "flow-agents", "dogfood-hook-demo");
 fs.mkdirSync(taskDir, { recursive: true });
 const state = {
   schema_version: "1.0",