pi-harness-runtime 1.1.439 → 1.1.441

package/packages/a2a-adapter/test/a2a.test.ts

@@ -1,151 +0,0 @@
-/**
- * A2A Adapter Tests (RFC-0069)
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	createAgentCard,
-	routeTask,
-	getTask,
-	cancelTask,
-	taskStatusUpdateSSE,
-} from "../src/agent.js";
-import { A2AClient } from "../src/client.js";
-import { A2ATransport } from "../src/transport.js";
-import {
-	A2A_PROTOCOL_VERSION,
-	WELL_KNOWN_AGENT_PATH,
-} from "../src/protocol.js";
-import type { TaskMessage } from "../src/types.js";
-
-describe("A2A Protocol Constants", () => {
-	it("exports protocol version", () => {
-		expect(A2A_PROTOCOL_VERSION).toBe("1.0.0");
-	});
-
-	it("exports well-known agent path", () => {
-		expect(WELL_KNOWN_AGENT_PATH).toBe("/.well-known/agent.json");
-	});
-});
-
-describe("AgentCard", () => {
-	it("creates agent card with defaults", () => {
-		const card = createAgentCard({
-			name: "pi-harness",
-			description: "AI coding harness",
-			url: "http://localhost:3000",
-			version: "0.9.4",
-		});
-		expect(card.name).toBe("pi-harness");
-		expect(card.capabilities.streaming).toBe(true);
-		expect(card.skills.length).toBeGreaterThan(0);
-		expect(card.skills[0].id).toBe("code-analysis");
-	});
-
-	it("creates agent card with custom skills", () => {
-		const card = createAgentCard({
-			name: "test-agent",
-			description: "Test",
-			url: "http://localhost:3001",
-			version: "1.0.0",
-			skills: [
-				{
-					id: "custom",
-					name: "Custom",
-					description: "Custom skill",
-					tags: ["test"],
-				},
-			],
-		});
-		expect(card.skills).toHaveLength(1);
-		expect(card.skills[0].id).toBe("custom");
-	});
-
-	it("merges custom capabilities", () => {
-		const card = createAgentCard({
-			name: "test",
-			description: "Test",
-			url: "http://localhost:3002",
-			version: "1.0.0",
-			capabilities: { pushNotifications: true },
-		});
-		expect(card.capabilities.streaming).toBe(true);
-		expect(card.capabilities.pushNotifications).toBe(true);
-	});
-});
-
-describe("Task Routing", () => {
-	it("routes a task message", async () => {
-		const message: TaskMessage = { role: "user", content: "Analyze this code" };
-		const task = await routeTask(message);
-		expect(task.id).toMatch(/^task-/);
-		expect(task.status).toBe("completed");
-		expect(task.artifacts).toHaveLength(1);
-		expect(task.artifacts![0].parts[0].text).toContain("Analyze this code");
-	});
-
-	it("stores and retrieves task", async () => {
-		const message: TaskMessage = { role: "user", content: "Test" };
-		const task = await routeTask(message);
-		const retrieved = getTask(task.id);
-		expect(retrieved).not.toBeNull();
-		expect(retrieved!.id).toBe(task.id);
-	});
-
-	it("returns null for unknown task", () => {
-		expect(getTask("nonexistent-task")).toBeNull();
-	});
-
-	it("cancels a task", async () => {
-		const message: TaskMessage = { role: "user", content: "Cancel test" };
-		const task = await routeTask(message);
-		expect(task.status).toBe("completed");
-		const result = cancelTask(task.id);
-		expect(result).toBe(true);
-		expect(getTask(task.id)!.status).toBe("canceled");
-	});
-
-	it("returns false when canceling unknown task", () => {
-		expect(cancelTask("nonexistent")).toBe(false);
-	});
-
-	it("generates SSE status update", async () => {
-		const message: TaskMessage = { role: "user", content: "SSE test" };
-		const task = await routeTask(message);
-		const sse = taskStatusUpdateSSE(task.id);
-		expect(sse).toContain("task_status_update");
-		expect(sse).toContain(task.id);
-		expect(sse).toContain("completed");
-		expect(sse).toContain("final");
-	});
-});
-
-describe("A2AClient", () => {
-	it("creates client with URL", () => {
-		const client = new A2AClient("http://localhost:3000");
-		expect(client).toBeDefined();
-	});
-
-	it("sendTask throws on unreachable server", async () => {
-		const client = new A2AClient("http://localhost:9999");
-		await expect(client.sendTask("test")).rejects.toThrow();
-	});
-
-	it("findAgents returns empty array", async () => {
-		const client = new A2AClient("http://localhost:3000");
-		const results = await client.findAgents({ skill: "test" });
-		expect(results).toEqual([]);
-	});
-});
-
-describe("A2ATransport", () => {
-	it("creates transport with config", () => {
-		const t = new A2ATransport("http://localhost:3000", { timeout: 5000 });
-		expect(t).toBeDefined();
-	});
-
-	it("getAgentCard throws on invalid URL", async () => {
-		const t = new A2ATransport("http://localhost:9999", { timeout: 2000 });
-		await expect(t.getAgentCard()).rejects.toThrow();
-	});
-});

package/packages/agent-policy/test/interlock.test.ts

@@ -1,101 +0,0 @@
-import { afterEach, beforeEach, expect, test } from "bun:test";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { registerAgentPolicy } from "../src/extension.js";
-import { PolicyLoader } from "../src/policy-loader.js";
-import { resetPolicyStore } from "../src/policy-store.js";
-
-let root: string;
-let cwd: string;
-let harnessRulesPath: URL;
-beforeEach(() => {
-  resetPolicyStore();
-  root = mkdtempSync(join(tmpdir(), "policy-interlock-"));
-  cwd = join(root, "project");
-  mkdirSync(join(cwd, "src"), { recursive: true });
-  mkdirSync(join(cwd, ".git"));
-  writeFileSync(join(root, "harness.md"), "Harness mandatory rules");
-  writeFileSync(join(root, "AGENTS.md"), "Ancestor mandatory rules");
-  writeFileSync(join(cwd, "AGENTS.md"), "Project mandatory rules");
-  writeFileSync(join(cwd, "RULES.md"), "Advisory rules");
-  harnessRulesPath = pathToFileURL(join(root, "harness.md"));
-});
-afterEach(() => rmSync(root, { recursive: true, force: true }));
-
-function runtime(requireReceiptBeforeMutation = true) {
-  const hooks = new Map<string, Function[]>();
-  let tool: any;
-  registerAgentPolicy({
-    on(name: string, handler: Function) {
-      hooks.set(name, [...(hooks.get(name) ?? []), handler]);
-    },
-    registerTool(value: unknown) { tool = value; },
-  } as any, { harnessRulesPath, requireReceiptBeforeMutation, lspMode: "pi-lens" });
-  return {
-    call: (params: unknown, ctx: unknown) => tool.execute("test", params, undefined, undefined, ctx),
-    gate: (ctx: unknown, path = "src/file.ts") => hooks.get("tool_call")![0](
-      { toolName: "edit", input: { path } }, ctx),
-  };
-}
-
-test("target checks preserve mandatory revision, ancestor rules, and cached manifest", async () => {
-  const loader = new PolicyLoader({ harnessRulesPath });
-  const manifest = await loader.load(cwd);
-  const snapshot = JSON.stringify(manifest);
-  for (const path of ["src/file.ts", join(cwd, "src/file.ts"), "packages/a/file.ts"]) {
-    const target = await loader.loadForTarget(cwd, path);
-    expect(target.revision).toBe(manifest.revision);
-    expect(target.sources.some(s => s.path === join(root, "AGENTS.md"))).toBe(true);
-    expect(JSON.stringify(manifest)).toBe(snapshot);
-  }
-  loader.invalidateCache();
-  expect((await loader.load(cwd)).revision).toBe(manifest.revision);
-});
-
-test("acknowledgment unlocks the next target call using Pi sessionManager identity", async () => {
-  const r = runtime();
-  const context = (id = "session-a") => ({ cwd, sessionManager: { getSessionId: () => id } });
-  expect((await r.gate(context())).block).toBe(true);
-  const revision = (await r.call({ action: "manifest" }, context())).details.manifest.revision;
-  expect((await r.call({ action: "acknowledge", revision }, context())).isError).not.toBe(true);
-  expect((await r.gate(context())).block).not.toBe(true);
-  expect((await r.gate(context(), join(cwd, "src/file.ts"))).block).not.toBe(true);
-  expect((await r.gate(context("session-b"))).block).toBe(true);
-});
-
-test("legacy contexts reuse a stable fallback identity", async () => {
-  const r = runtime();
-  const revision = (await r.call({ action: "manifest" }, { cwd })).details.manifest.revision;
-  await r.call({ action: "acknowledge", revision }, { cwd });
-  expect((await r.gate({ cwd })).block).not.toBe(true);
-});
-
-test("explicitly disabled receipt enforcement allows tools without an acknowledgment", async () => {
-  const r = runtime(false);
-  expect((await r.gate({ cwd })).block).not.toBe(true);
-});
-
-test("wrong revisions remain rejected when receipt enforcement is enabled", async () => {
-  const r = runtime();
-  const ctx = { cwd, sessionId: "session-a" };
-  const result = await r.call({ action: "acknowledge", revision: "stale" }, ctx);
-  expect(result.isError).toBe(true);
-  expect((await r.gate(ctx)).block).toBe(true);
-});
-
-test("rule changes still require a new receipt after policy cache refresh", async () => {
-  const r = runtime();
-  const ctx = { cwd, sessionId: "session-a" };
-  const revision = (await r.call({ action: "manifest" }, ctx)).details.manifest.revision;
-  await r.call({ action: "acknowledge", revision }, ctx);
-  writeFileSync(join(cwd, "AGENTS.md"), "Updated mandatory rules");
-  // A fresh loader/registration models cache refresh without a five-second wait.
-  const refreshed = runtime();
-  expect((await refreshed.gate(ctx)).block).toBe(true);
-  const current = (await refreshed.call({ action: "manifest" }, ctx)).details.manifest.revision;
-  expect(current).not.toBe(revision);
-  await refreshed.call({ action: "acknowledge", revision: current }, ctx);
-  expect((await refreshed.gate(ctx)).block).not.toBe(true);
-});

package/packages/agent-policy/test/policy-retention.test.ts

@@ -1,380 +0,0 @@
-/**
- * Policy Retention Tests
- *
- * Tests for lifecycle retention after compaction, reset, resume.
- */
-
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert";
-import { existsSync, mkdirSync, writeFileSync, unlinkSync, rmSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { randomUUID } from "node:crypto";
-import type { PolicyManifest } from "../dist/types.js";
-import { PolicyLoader } from "../dist/policy-loader.js";
-import { getPolicyStore, resetPolicyStore } from "../dist/policy-store.js";
-
-// Test workspace
-const TEST_DIR = "/tmp/policy-retention-test-" + Date.now();
-const AGENTS_MD = join(TEST_DIR, "AGENTS.md");
-const RULES_MD = join(TEST_DIR, "RULES.md");
-
-describe("Policy Retention Tests", () => {
-  before(() => {
-    mkdirSync(TEST_DIR, { recursive: true });
-    resetPolicyStore();
-  });
-
-  after(() => {
-    try {
-      rmSync(TEST_DIR, { recursive: true, force: true });
-    } catch {
-      // ignore cleanup errors
-    }
-    resetPolicyStore();
-  });
-
-  // --- Session Epoch Tests ---
-  describe("Session epochs", () => {
-    it("should track session epochs separately", async () => {
-      const store = getPolicyStore();
-      const session1 = "session-1-" + randomUUID().slice(0, 8);
-      const session2 = "session-2-" + randomUUID().slice(0, 8);
-
-      // Create a manifest
-      const manifest: PolicyManifest = {
-        revision: "abc123",
-        projectRoot: TEST_DIR,
-        trust: "unknown",
-        coverage: "complete",
-        sources: [],
-        loadedAt: Date.now(),
-      };
-
-      // Note delivery for session 1
-      const receipt1 = store.noteDelivered(session1, manifest, "system_prompt");
-      assert.strictEqual(receipt1.sessionId, session1);
-
-      // Session 2 should NOT have a receipt
-      const receipt2 = store.getReceipt(session2, TEST_DIR);
-      assert.strictEqual(receipt2, null);
-    });
-
-    it("should not leak receipts between sessions after reset", async () => {
-      const store = getPolicyStore();
-      const sessionId = "session-reset-" + randomUUID().slice(0, 8);
-
-      const manifest: PolicyManifest = {
-        revision: "abc123",
-        projectRoot: TEST_DIR,
-        trust: "unknown",
-        coverage: "complete",
-        sources: [],
-        loadedAt: Date.now(),
-      };
-
-      // Deliver to session
-      store.noteDelivered(sessionId, manifest, "system_prompt");
-
-      // Clear session
-      store.clearSession(sessionId);
-
-      // Receipt should be gone
-      const receipt = store.getReceipt(sessionId, TEST_DIR);
-      assert.strictEqual(receipt, null);
-    });
-  });
-
-  // --- Source Change Tests ---
-  describe("Source changes", () => {
-    it("should invalidate receipts when AGENTS.md changes", async () => {
-      const store = getPolicyStore();
-      const sessionId = "session-change-" + randomUUID().slice(0, 8);
-
-      // Write initial content
-      writeFileSync(AGENTS_MD, "# Original Agents\n\nFollow the rules.", "utf8");
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      // Load and deliver
-      const manifest1 = await loader.load(TEST_DIR);
-      store.noteDelivered(sessionId, manifest1, "system_prompt");
-
-      // Modify file
-      writeFileSync(AGENTS_MD, "# Updated Agents\n\nDifferent rules.", "utf8");
-
-      // Invalidate cache
-      loader.invalidateCache(TEST_DIR);
-
-      // Load new manifest
-      const manifest2 = await loader.load(TEST_DIR);
-
-      // Revision should be different
-      assert.notStrictEqual(manifest1.revision, manifest2.revision);
-
-      // Old receipt should NOT cover new manifest
-      const hasCoverage = store.hasValidReceipt(sessionId, manifest2);
-      assert.strictEqual(hasCoverage, false);
-    });
-
-    it("should include RULES.md in sources", async () => {
-      // Write RULES.md
-      writeFileSync(RULES_MD, "# Rules\n\nThese are rules.", "utf8");
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      const manifest = await loader.load(TEST_DIR);
-
-      // RULES.md should be included as advisory at minimum
-      const rulesSource = manifest.sources.find(s => s.path.includes("RULES.md"));
-      assert.ok(rulesSource, "RULES.md should be included in sources");
-
-      // Clean up
-      unlinkSync(RULES_MD);
-    });
-  });
-
-  // --- Bounded Delivery Tests ---
-  describe("Bounded delivery", () => {
-    it("should track exact revision and source coverage", async () => {
-      const store = getPolicyStore();
-      const sessionId = "session-exact-" + randomUUID().slice(0, 8);
-
-      writeFileSync(AGENTS_MD, "# Agents\n\nContent.", "utf8");
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      const manifest = await loader.load(TEST_DIR);
-
-      // Note delivery with specific sections
-      const receipt = store.noteDelivered(sessionId, manifest, "tool", ["section-1"]);
-
-      assert.strictEqual(receipt.revision, manifest.revision);
-      assert.deepStrictEqual(receipt.sectionsDelivered, ["section-1"]);
-    });
-
-    it("should reject acknowledgement of wrong revision", async () => {
-      const store = getPolicyStore();
-      const sessionId = "session-wrong-rev-" + randomUUID().slice(0, 8);
-
-      writeFileSync(AGENTS_MD, "# Agents v1\n\nContent.", "utf8");
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      const manifest1 = await loader.load(TEST_DIR);
-      store.noteDelivered(sessionId, manifest1, "system_prompt");
-
-      // Update content
-      writeFileSync(AGENTS_MD, "# Agents v2\n\nDifferent content.", "utf8");
-      loader.invalidateCache(TEST_DIR);
-      const manifest2 = await loader.load(TEST_DIR);
-
-      // Old receipt should NOT cover new manifest
-      const hasCoverage = store.hasValidReceipt(sessionId, manifest2);
-      assert.strictEqual(hasCoverage, false);
-    });
-  });
-
-  // --- Trust Evaluation Tests ---
-  describe("Trust evaluation", () => {
-    it("should evaluate trust appropriately", async () => {
-      // Create a .git directory (indicates repository)
-      mkdirSync(join(TEST_DIR, ".git"), { recursive: true });
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      const manifest = await loader.load(TEST_DIR);
-
-      // Trust should be evaluated
-      assert.ok(["trusted", "untrusted", "unknown"].includes(manifest.trust));
-
-      // Clean up
-      rmSync(join(TEST_DIR, ".git"), { recursive: true, force: true });
-    });
-  });
-
-  // --- Compaction Recovery Tests ---
-  describe("Compaction recovery", () => {
-    it("should invalidate receipts on session_compact event", async () => {
-      const store = getPolicyStore();
-      const sessionId = "session-compact-" + randomUUID().slice(0, 8);
-
-      writeFileSync(AGENTS_MD, "# Agents\n\nContent.", "utf8");
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      const manifest = await loader.load(TEST_DIR);
-      store.noteDelivered(sessionId, manifest, "system_prompt");
-
-      // Simulate compaction: invalidate all
-      store.invalidateAll();
-
-      // Receipt should be gone
-      const receipt = store.getReceipt(sessionId, TEST_DIR);
-      assert.strictEqual(receipt, null);
-    });
-  });
-
-  // --- Nested Scope Tests ---
-  describe("Nested scope resolution", () => {
-    it("should load scoped rules for subdirectories", async () => {
-      // Create nested structure
-      mkdirSync(join(TEST_DIR, "packages", "my-pkg"), { recursive: true });
-      writeFileSync(AGENTS_MD, "# Root Agents\n\nRoot rules.", "utf8");
-      writeFileSync(join(TEST_DIR, "packages", "AGENTS.md"), "# Package Agents\n\nPackage rules.", "utf8");
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      const manifest = await loader.load(TEST_DIR);
-
-      // Should have both root and package rules
-      assert.ok(manifest.sources.length >= 2, "Should include both root and package rules");
-
-      // Clean up nested structure
-      rmSync(join(TEST_DIR, "packages"), { recursive: true, force: true });
-    });
-  });
-
-  // --- Delivery Deduplication Tests ---
-  describe("Delivery deduplication", () => {
-    it("should not create duplicate receipts in same session", async () => {
-      const store = getPolicyStore();
-      const sessionId = "session-dedup-" + randomUUID().slice(0, 8);
-
-      writeFileSync(AGENTS_MD, "# Agents\n\nContent.", "utf8");
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      const manifest = await loader.load(TEST_DIR);
-
-      // First delivery
-      const receipt1 = store.noteDelivered(sessionId, manifest, "system_prompt");
-
-      // Second delivery should update, not create duplicate
-      const receipt2 = store.noteDelivered(sessionId, manifest, "system_prompt");
-
-      // Should be same session
-      assert.strictEqual(receipt1.sessionId, receipt2.sessionId);
-
-      // Should have same revision
-      assert.strictEqual(receipt1.revision, receipt2.revision);
-    });
-  });
-
-  // --- Partial Read Tracking Tests ---
-  describe("Partial read tracking", () => {
-    it("should track which sections were actually delivered", async () => {
-      const store = getPolicyStore();
-      const sessionId = "session-partial-" + randomUUID().slice(0, 8);
-
-      writeFileSync(AGENTS_MD, "# Agents\n\n## Section 1\n\nContent 1.\n\n## Section 2\n\nContent 2.", "utf8");
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      const manifest = await loader.load(TEST_DIR);
-
-      // Note partial delivery (only section 1)
-      const receipt = store.noteDelivered(sessionId, manifest, "tool", ["section-1"]);
-      assert.deepStrictEqual(receipt.sectionsDelivered, ["section-1"]);
-    });
-  });
-
-  // --- Full Policy Text Delivery Tests ---
-  describe("Full policy text delivery", () => {
-    it("should compute full policy text after revision change", async () => {
-      writeFileSync(AGENTS_MD, "# Full Agents\n\n## Rule 1\n\nContent 1.\n\n## Rule 2\n\nContent 2.", "utf8");
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      const manifest = await loader.load(TEST_DIR);
-
-      // Full text should include actual content, not just contract pointers
-      const { renderFullPolicyText } = await import("../dist/index.js");
-      const fullText = renderFullPolicyText(manifest);
-
-      assert.ok(fullText.includes("Full Agents"), "Should include source title");
-      assert.ok(fullText.includes("Rule 1"), "Should include section heading");
-      assert.ok(fullText.includes("Content 1"), "Should include actual content");
-      assert.ok(fullText.includes("revision="), "Should include revision info");
-    });
-
-    it("should detect when full policy exceeds size limit", async () => {
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      const manifest = await loader.load(TEST_DIR);
-      const { checkPolicyTextSize } = await import("../dist/index.js");
-
-      // With normal-sized content, should fit in 100KB limit
-      const result = checkPolicyTextSize(manifest, 100 * 1024);
-      assert.strictEqual(result.fits, true, "Normal policy should fit in 100KB");
-
-      // With very small limit, should report overflow
-      const smallResult = checkPolicyTextSize(manifest, 10);
-      assert.strictEqual(smallResult.fits, false, "Should report when limit is too small");
-      assert.ok(smallResult.reason?.includes("exceeds limit"), "Should explain overflow");
-    });
-  });
-
-  // --- Scope Separation Tests ---
-  describe("Scope separation", () => {
-    it("should NOT include harness rules when working outside harness repo", async () => {
-      // Create a harness rules file in a different location
-      const harnessRulesPath = join(TEST_DIR, "harness-rules", "AGENTS.md");
-      mkdirSync(dirname(harnessRulesPath), { recursive: true });
-      writeFileSync(harnessRulesPath, "# Harness Rules\n\nThese are harness-specific rules.", "utf8");
-
-      // Working in a different directory (not the harness repo)
-      const userProjectDir = join(TEST_DIR, "user-project");
-      mkdirSync(userProjectDir, { recursive: true });
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${harnessRulesPath}`),
-      });
-
-      const manifest = await loader.load(userProjectDir);
-
-      // Harness rules should NOT be included since we're not in the harness repo
-      const harnessSources = manifest.sources.filter(s => s.harnessOwned);
-      assert.strictEqual(harnessSources.length, 0, "Harness rules should not apply outside harness repo");
-    });
-
-    it("should include harness rules when working inside harness repo", async () => {
-      // Create a harness rules file
-      writeFileSync(AGENTS_MD, "# Harness Rules\n\nThese are harness-specific rules.", "utf8");
-
-      const harnessDir = TEST_DIR; // The harness rules are in this directory
-
-      const loader = new PolicyLoader({
-        harnessRulesPath: new URL(`file://${AGENTS_MD}`),
-      });
-
-      // Working in the harness directory itself
-      const manifest = await loader.load(harnessDir);
-
-      // Harness rules SHOULD be included since we're in the harness repo
-      const harnessSources = manifest.sources.filter(s => s.harnessOwned);
-      assert.ok(harnessSources.length > 0, "Harness rules should apply inside harness repo");
-    });
-  });
-});