pi-harness-runtime 0.9.4 → 0.9.6

package/packages/runtime/test/runtime.test.ts

@@ -0,0 +1,297 @@
+/**
+ * Runtime Tests — Policy Engine & Runtime API
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+	PolicyEngine,
+	createHarnessPolicyEngine,
+	type PolicyContext,
+} from "../src/policy-engine.js";
+
+describe("PolicyEngine", () => {
+	let engine: PolicyEngine;
+
+	beforeEach(() => {
+		engine = new PolicyEngine();
+	});
+
+	describe("defaults", () => {
+		it("denies rm -rf /", () => {
+			const result = engine.canExecuteCommand("rm -rf /");
+			expect(result.effect).toBe("deny");
+		});
+
+		it("allows git commands", () => {
+			const result = engine.canExecuteCommand("git status");
+			expect(result.effect).toBe("allow");
+		});
+
+		it("allows npm/npx commands", () => {
+			expect(engine.canExecuteCommand("npm install").effect).toBe("allow");
+			expect(engine.canExecuteCommand("npx test").effect).toBe("allow");
+		});
+
+		it("allows HTTPS network requests", () => {
+			const result = engine.canMakeNetworkRequest("https://api.example.com");
+			expect(result.effect).toBe("allow");
+		});
+
+		it("denies HTTP network requests by default", () => {
+			const result = engine.canMakeNetworkRequest(
+				"http://insecure.example.com",
+			);
+			expect(result.effect).toBe("ask"); // Default ask, not explicit deny
+		});
+
+		it("denies private network access", () => {
+			const result = engine.canMakeNetworkRequest("10.0.0.1");
+			expect(result.effect).toBe("deny");
+		});
+
+		it("denies localhost network access", () => {
+			const result = engine.canMakeNetworkRequest("localhost");
+			expect(result.effect).toBe("deny");
+		});
+
+		it("denies file access outside workspace (.. paths)", () => {
+			const result = engine.canAccessFile("../secret.txt", "read");
+			expect(result.effect).toBe("deny");
+		});
+
+		it("defaults to ask for unknown resources", () => {
+			const ctx: PolicyContext = {
+				subject: {},
+				resource: { type: "command", path: "unknown-cmd" },
+			};
+			const result = engine.evaluate(ctx);
+			expect(result.effect).toBe("ask");
+		});
+	});
+
+	describe("addPolicy / removePolicy", () => {
+		it("adds a custom allow policy", () => {
+			engine.addPolicy({
+				id: "allow-my-cmd",
+				name: "Allow my command",
+				priority: 5,
+				effect: "allow",
+				condition: {
+					resource: { pathPattern: "^my-script" },
+				},
+			});
+
+			const result = engine.canExecuteCommand("my-script.sh");
+			expect(result.effect).toBe("allow");
+		});
+
+		it("higher priority policies override lower", () => {
+			engine.addPolicy({
+				id: "allow-any",
+				name: "Allow all",
+				priority: 1,
+				effect: "allow",
+				condition: { resource: { type: "command" } },
+			});
+			engine.addPolicy({
+				id: "deny-specific",
+				name: "Deny specific",
+				priority: 50,
+				effect: "deny",
+				condition: {
+					resource: { pathPattern: "git" },
+				},
+			});
+
+			const result = engine.canExecuteCommand("git status");
+			expect(result.effect).toBe("deny");
+		});
+
+		it("removes policy by id", () => {
+			engine.addPolicy({
+				id: "temp-policy",
+				name: "Temp",
+				priority: 5,
+				effect: "allow",
+				condition: { resource: { type: "command" } },
+			});
+			expect(engine.removePolicy("temp-policy")).toBe(true);
+			expect(engine.removePolicy("nonexistent")).toBe(false);
+		});
+
+		it("getPolicies returns all policies", () => {
+			engine.addPolicy({
+				id: "p1",
+				name: "Policy 1",
+				priority: 1,
+				effect: "allow",
+				condition: { resource: { type: "command" } },
+			});
+			const policies = engine.getPolicies();
+			expect(policies.some((p) => p.id === "p1")).toBe(true);
+		});
+	});
+
+	describe("canExecuteCommand", () => {
+		it("returns policy name in result", () => {
+			const result = engine.canExecuteCommand("git status");
+			expect(result.policy).toBeDefined();
+		});
+	});
+
+	describe("canAccessFile", () => {
+		it("allows reading safe paths", () => {
+			const result = engine.canAccessFile("/home/project/src/index.ts", "read");
+			expect(result.effect).not.toBe("deny");
+		});
+	});
+
+	describe("canMakeNetworkRequest", () => {
+		it("allows github HTTPS", () => {
+			const result = engine.canMakeNetworkRequest("https://github.com/api");
+			expect(result.effect).toBe("allow");
+		});
+	});
+
+	describe("addCommandRule", () => {
+		it("adds regex-based command rule", () => {
+			engine.addCommandRule(/^curl\s+/, "allow", "curl allowed");
+			const result = engine.canExecuteCommand("curl https://example.com");
+			expect(result.effect).toBe("allow");
+			expect(result.reason).toBe("curl allowed");
+		});
+	});
+
+	describe("addFileRule", () => {
+		it("adds regex-based file rule", () => {
+			engine.addFileRule(/\.log$/, "deny", "No log files");
+			const result = engine.canAccessFile("/tmp/debug.log", "read");
+			expect(result.effect).toBe("deny");
+		});
+	});
+
+	describe("addNetworkRule", () => {
+		it("adds regex-based network rule", () => {
+			engine.addNetworkRule(
+				/internal\.company\.com/,
+				"deny",
+				"Internal hosts blocked",
+			);
+			const result = engine.canMakeNetworkRequest(
+				"https://internal.company.com",
+			);
+			expect(result.effect).toBe("deny");
+		});
+	});
+
+	describe("rate limiting", () => {
+		it("enforces rate limits via custom policy", () => {
+			// Add policy with custom rate limit condition
+			let callCount = 0;
+			engine.addPolicy({
+				id: "rate-limit-test",
+				name: "Rate Limit Test",
+				priority: 50,
+				effect: "deny",
+				condition: {
+					resource: { type: "command" },
+					custom: () => {
+						callCount++;
+						return callCount > 3;
+					},
+				},
+				reason: "Rate limit exceeded",
+			});
+
+			// First 3 should be allowed (no policy match)
+			expect(engine.canExecuteCommand("git status").effect).toBe("allow");
+			expect(engine.canExecuteCommand("git status").effect).toBe("allow");
+			expect(engine.canExecuteCommand("git status").effect).toBe("allow");
+
+			// 4th should be denied
+			const result = engine.canExecuteCommand("git status");
+			expect(result.effect).toBe("deny");
+		});
+
+		it("getRateLimit returns configured limit", () => {
+			engine.setRateLimit("network", { maxRequests: 50, windowMs: 60000 });
+			const limit = engine.getRateLimit("network");
+			expect(limit?.maxRequests).toBe(50);
+			expect(limit?.windowMs).toBe(60000);
+		});
+	});
+
+	describe("audit log", () => {
+		it("logs audited policies", () => {
+			engine.addPolicy({
+				id: "audit-test",
+				name: "Audit Test",
+				priority: 5,
+				effect: "allow",
+				audit: true,
+				condition: {
+					resource: { type: "command", pathPattern: "^test-audit" },
+				},
+			});
+
+			engine.canExecuteCommand("test-audit");
+			const log = engine.getAuditLog();
+			expect(log.length).toBeGreaterThan(0);
+		});
+
+		it("filters audit log by effect", () => {
+			engine.clearAuditLog();
+			const log = engine.getAuditLog({ effect: "deny" });
+			expect(Array.isArray(log)).toBe(true);
+		});
+
+		it("clears audit log", () => {
+			engine.clearAuditLog();
+			expect(engine.getAuditLog()).toEqual([]);
+		});
+	});
+
+	describe("export/import policies", () => {
+		it("exports policies as JSON", () => {
+			const json = engine.exportPolicies();
+			expect(json).toContain("policies");
+			expect(json).toContain("commandRules");
+		});
+
+		it("imports policies from JSON", () => {
+			const original = engine.exportPolicies();
+			const imported = new PolicyEngine();
+			expect(imported.importPolicies(original)).toBe(true);
+
+			// After import, should still deny rm -rf
+			expect(imported.canExecuteCommand("rm -rf /").effect).toBe("deny");
+		});
+
+		it("returns false for invalid JSON", () => {
+			expect(engine.importPolicies("not valid json")).toBe(false);
+		});
+	});
+});
+
+describe("createHarnessPolicyEngine", () => {
+	it("creates engine with harness-specific policies", () => {
+		const engine = createHarnessPolicyEngine();
+
+		// Should still deny dangerous commands
+		expect(engine.canExecuteCommand("rm -rf /").effect).toBe("deny");
+
+		// Should allow harness internal commands
+		expect(engine.canExecuteCommand("pi-status").effect).toBe("allow");
+		expect(engine.canExecuteCommand("harness-status").effect).toBe("allow");
+
+		// Should deny system commands
+		expect(engine.canExecuteCommand("sudo rm /").effect).toBe("deny");
+	});
+
+	it("has rate limits configured", () => {
+		const engine = createHarnessPolicyEngine();
+		expect(engine.getRateLimit("command")?.maxRequests).toBe(60);
+		expect(engine.getRateLimit("network")?.maxRequests).toBe(100);
+		expect(engine.getRateLimit("file")?.maxRequests).toBe(200);
+	});
+});

package/packages/runtime/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/packages/scheduler/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@pi-harness/scheduler",
+  "version": "0.9.6",
+  "description": "pi-harness-runtime — scheduler",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {}
+}

package/packages/scheduler/test/scheduler.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Scheduler Tests
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { JsonRuntimeScheduler } from "../src/scheduler";
+
+const TMP = join(process.cwd(), ".test-scheduler-tmp");
+
+function scheduler(): JsonRuntimeScheduler {
+	return new JsonRuntimeScheduler(TMP);
+}
+
+beforeEach(() => {
+	rmSync(TMP, { force: true, recursive: true });
+	mkdirSync(TMP, { recursive: true });
+});
+
+describe("JsonRuntimeScheduler", () => {
+	describe("scheduleResume", () => {
+		it("writes a job to schedule.json", async () => {
+			const s = scheduler();
+			await s.scheduleResume("job-1", "2025-01-01T12:00:00Z", "test reason");
+			const jobs = await s.readAll();
+			expect(jobs).toHaveLength(1);
+			expect(jobs[0].jobId).toBe("job-1");
+			expect(jobs[0].status).toBe("scheduled");
+			expect(jobs[0].reason).toBe("test reason");
+		});
+
+		it("overwrites existing job with same ID", async () => {
+			const s = scheduler();
+			await s.scheduleResume("job-1", "2025-01-01T12:00:00Z", "reason A");
+			await s.scheduleResume("job-1", "2025-01-02T12:00:00Z", "reason B");
+			const jobs = await s.readAll();
+			expect(jobs).toHaveLength(1);
+			expect(jobs[0].reason).toBe("reason B");
+		});
+
+		it("keeps separate jobs distinct", async () => {
+			const s = scheduler();
+			await s.scheduleResume("job-A", "2025-01-01T12:00:00Z", "reason A");
+			await s.scheduleResume("job-B", "2025-01-02T12:00:00Z", "reason B");
+			const jobs = await s.readAll();
+			expect(jobs).toHaveLength(2);
+		});
+	});
+
+	describe("dueJobs", () => {
+		it("returns empty when nothing is due", async () => {
+			const s = scheduler();
+			await s.scheduleResume("job-1", "2099-12-31T23:59:59Z", "far future");
+			const due = await s.dueJobs(new Date("2025-01-01"));
+			expect(due).toHaveLength(0);
+		});
+
+		it("returns job when resumeAt has passed", async () => {
+			const s = scheduler();
+			await s.scheduleResume("job-1", "2024-01-01T12:00:00Z", "past");
+			const due = await s.dueJobs(new Date("2025-01-01"));
+			expect(due).toEqual(["job-1"]);
+		});
+
+		it("skips cancelled jobs", async () => {
+			const s = scheduler();
+			await s.scheduleResume("job-1", "2024-01-01T12:00:00Z", "cancelled");
+			await s.cancel("job-1");
+			const due = await s.dueJobs(new Date("2025-01-01"));
+			expect(due).toHaveLength(0);
+		});
+
+		it("returns multiple due jobs", async () => {
+			const s = scheduler();
+			await s.scheduleResume("job-A", "2024-01-01T12:00:00Z", "A");
+			await s.scheduleResume("job-B", "2024-01-02T12:00:00Z", "B");
+			await s.cancel("job-A");
+			const due = await s.dueJobs(new Date("2025-01-01"));
+			expect(due).toEqual(["job-B"]);
+		});
+
+		it("ignores resumeAt in the future", async () => {
+			const s = scheduler();
+			await s.scheduleResume("job-future", "2099-01-01T00:00:00Z", "too late");
+			const due = await s.dueJobs(new Date("2025-06-15"));
+			expect(due).toHaveLength(0);
+		});
+	});
+
+	describe("cancel", () => {
+		it("sets status to cancelled", async () => {
+			const s = scheduler();
+			await s.scheduleResume("job-1", "2024-01-01T00:00:00Z", "to cancel");
+			await s.cancel("job-1");
+			const jobs = await s.readAll();
+			expect(jobs).toHaveLength(1);
+			expect(jobs[0].status).toBe("cancelled");
+		});
+
+		it("no-op for unknown job", async () => {
+			const s = scheduler();
+			await s.scheduleResume("job-1", "2024-01-01T00:00:00Z", "exists");
+			await s.cancel("nonexistent");
+			const jobs = await s.readAll();
+			expect(jobs).toHaveLength(1);
+		});
+
+		it("cancelled job not returned by dueJobs", async () => {
+			const s = scheduler();
+			await s.scheduleResume("job-1", "2020-01-01T00:00:00Z", "was due");
+			await s.cancel("job-1");
+			const due = await s.dueJobs(new Date("2025-01-01"));
+			expect(due).toHaveLength(0);
+		});
+	});
+
+	describe("readAll", () => {
+		it("returns empty array for missing file", async () => {
+			const s = scheduler();
+			const jobs = await s.readAll();
+			expect(jobs).toEqual([]);
+		});
+	});
+});

package/packages/session/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/session",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Session management system for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/shared-context/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@pi-harness/shared-context",
+  "version": "0.9.6",
+  "description": "pi-harness-runtime — shared-context",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {}
+}

package/packages/shared-context/src/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared Context (RFC-0009)
+ *
+ * In-memory shared context store for session data.
+ */
+
+export * from "./shared-context.js";

package/packages/shared-context/test/shared-context.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Shared Context Store Tests
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { FileSharedContextStore } from "../src/shared-context";
+
+const TMP = join(process.cwd(), ".test-context-tmp");
+
+function store(): FileSharedContextStore {
+	return new FileSharedContextStore(TMP);
+}
+
+beforeEach(() => {
+	rmSync(TMP, { force: true, recursive: true });
+	mkdirSync(TMP, { recursive: true });
+});
+
+describe("FileSharedContextStore", () => {
+	describe("writeRequirement / readRequirement", () => {
+		it("writes and reads back a requirement", async () => {
+			const s = store();
+			await s.writeRequirement("job-42", "Implement the login feature");
+			const text = await s.readRequirement("job-42");
+			expect(text).toBe("Implement the login feature\n");
+		});
+
+		it("returns null for missing requirement", async () => {
+			const s = store();
+			const text = await s.readRequirement("nonexistent-job");
+			expect(text).toBeNull();
+		});
+
+		it("overwrites existing requirement", async () => {
+			const s = store();
+			await s.writeRequirement("job-1", "original");
+			await s.writeRequirement("job-1", "updated");
+			const text = await s.readRequirement("job-1");
+			expect(text).toContain("updated");
+		});
+
+		it("handles multiline content", async () => {
+			const s = store();
+			const multiline = "Line 1\nLine 2\nLine 3";
+			await s.writeRequirement("job-3", multiline);
+			const text = await s.readRequirement("job-3");
+			expect(text).toBe("Line 1\nLine 2\nLine 3\n");
+		});
+	});
+
+	describe("writeResumePrompt", () => {
+		it("writes to resume_prompt.md", async () => {
+			const s = store();
+			await s.writeResumePrompt("job-7", "Resume context for job-7");
+			const text = await s.readRequirement("job-7");
+			expect(text).toBeNull(); // readRequirement reads requirement.md
+			// Read via the file system directly
+			const { readFileSync } = await import("node:fs");
+			const content = readFileSync(
+				join(TMP, "jobs", "job-7", "resume_prompt.md"),
+				"utf-8",
+			);
+			expect(content).toContain("Resume context for job-7");
+		});
+	});
+
+	describe("appendDecision", () => {
+		it("appends a decision entry", async () => {
+			const s = store();
+			await s.appendDecision("job-5", "Chose approach A because of simplicity");
+			const { readFileSync } = await import("node:fs");
+			const content = readFileSync(
+				join(TMP, "jobs", "job-5", "decisions.md"),
+				"utf-8",
+			);
+			expect(content).toContain("Chose approach A");
+			expect(content).toContain("## 20"); // ISO date prefix
+		});
+
+		it("appends multiple decisions sequentially", async () => {
+			const s = store();
+			await s.appendDecision("job-9", "Decision 1");
+			await s.appendDecision("job-9", "Decision 2");
+			const { readFileSync } = await import("node:fs");
+			const content = readFileSync(
+				join(TMP, "jobs", "job-9", "decisions.md"),
+				"utf-8",
+			);
+			expect(content).toContain("Decision 1");
+			expect(content).toContain("Decision 2");
+		});
+
+		it("creates intermediate directories", async () => {
+			const s = store();
+			await s.appendDecision("deeply-nested-job", "Made a decision");
+			const { existsSync } = await import("node:fs");
+			expect(existsSync(join(TMP, "jobs", "deeply-nested-job"))).toBe(true);
+		});
+	});
+
+	describe("multiple jobs", () => {
+		it("isolates jobs by ID", async () => {
+			const s = store();
+			await s.writeRequirement("job-A", "Content for A");
+			await s.writeRequirement("job-B", "Content for B");
+			const textA = await s.readRequirement("job-A");
+			const textB = await s.readRequirement("job-B");
+			expect(textA).toContain("Content for A");
+			expect(textB).toContain("Content for B");
+		});
+	});
+});

package/packages/skill-registry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/skill-registry",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Skill Registry for pi-harness-runtime — dynamic skill discovery and invocation",
   "type": "module",
   "main": "./dist/index.js",

package/packages/sprint-planner/dist/decomposer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Sprint Planner — Requirement Decomposer (RFC-0074)
+ */
+import type { Requirement, Task, StoryPoint } from "./types.js";
+/**
+ * Decompose a requirement into tasks
+ */
+export declare function decomposeRequirement(req: Requirement, options?: {
+    defaultEstimate?: StoryPoint;
+}): Task[];
+export declare function assignEstimate(complexity: number): StoryPoint;
+export declare function sumPoints(tasks: Task[]): number;
+//# sourceMappingURL=decomposer.d.ts.map

package/packages/sprint-planner/dist/decomposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decomposer.d.ts","sourceRoot":"","sources":["../src/decomposer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAIhE;;GAEG;AACH,wBAAgB,oBAAoB,CACnC,GAAG,EAAE,WAAW,EAChB,OAAO,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,UAAU,CAAA;CAAE,GACxC,IAAI,EAAE,CAeR;AAmBD,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAI7D;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,CAE/C"}

package/packages/sprint-planner/dist/decomposer.js

@@ -0,0 +1,38 @@
+/**
+ * Sprint Planner — Requirement Decomposer (RFC-0074)
+ */
+let taskCounter = 0;
+/**
+ * Decompose a requirement into tasks
+ */
+export function decomposeRequirement(req, options) {
+    const tasks = [];
+    const estimate = req.estimate ?? options?.defaultEstimate ?? 3;
+    tasks.push(createTask(req, "Implementation", "todo", estimate));
+    tasks.push(createTask(req, "Tests", "todo", Math.min(estimate, 5)));
+    tasks.push(createTask(req, "Documentation", "todo", 1));
+    for (const ac of req.acceptanceCriteria) {
+        tasks.push(createTask(req, `AC: ${ac}`, "todo", 2));
+    }
+    return tasks;
+}
+function createTask(req, title, status, estimate) {
+    return {
+        id: `task-${++taskCounter}-${Date.now()}`,
+        requirementId: req.id,
+        title: `${req.title} — ${title}`,
+        description: req.description,
+        status,
+        estimate,
+        labels: req.labels,
+    };
+}
+export function assignEstimate(complexity) {
+    const points = [1, 2, 3, 5, 8, 13, 21];
+    const idx = Math.min(Math.floor(complexity / 2), points.length - 1);
+    return points[idx];
+}
+export function sumPoints(tasks) {
+    return tasks.reduce((sum, t) => sum + (t.estimate ?? 0), 0);
+}
+//# sourceMappingURL=decomposer.js.map

package/packages/sprint-planner/dist/decomposer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decomposer.js","sourceRoot":"","sources":["../src/decomposer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,IAAI,WAAW,GAAG,CAAC,CAAC;AAEpB;;GAEG;AACH,MAAM,UAAU,oBAAoB,CACnC,GAAgB,EAChB,OAA0C;IAE1C,MAAM,KAAK,GAAW,EAAE,CAAC;IACzB,MAAM,QAAQ,GAAG,GAAG,CAAC,QAAQ,IAAI,OAAO,EAAE,eAAe,IAAI,CAAC,CAAC;IAE/D,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,gBAAgB,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAChE,KAAK,CAAC,IAAI,CACT,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAe,CAAC,CACrE,CAAC;IACF,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,eAAe,EAAE,MAAM,EAAE,CAAe,CAAC,CAAC,CAAC;IAEtE,KAAK,MAAM,EAAE,IAAI,GAAG,CAAC,kBAAkB,EAAE,CAAC;QACzC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,CAAe,CAAC,CAAC,CAAC;IACnE,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC;AAED,SAAS,UAAU,CAClB,GAAgB,EAChB,KAAa,EACb,MAAsB,EACtB,QAAoB;IAEpB,OAAO;QACN,EAAE,EAAE,QAAQ,EAAE,WAAW,IAAI,IAAI,CAAC,GAAG,EAAE,EAAE;QACzC,aAAa,EAAE,GAAG,CAAC,EAAE;QACrB,KAAK,EAAE,GAAG,GAAG,CAAC,KAAK,MAAM,KAAK,EAAE;QAChC,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,MAAM;QACN,QAAQ;QACR,MAAM,EAAE,GAAG,CAAC,MAAM;KAClB,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,UAAkB;IAChD,MAAM,MAAM,GAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACrD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACpE,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;AACpB,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,KAAa;IACtC,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC7D,CAAC"}

package/packages/sprint-planner/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sprint Planner — Main Entry (RFC-0074)
+ */
+export { planSprints, createSprintConfig, sortRequirements, calculateVelocity, } from "./planner.js";
+export { decomposeRequirement, assignEstimate, sumPoints, } from "./decomposer.js";
+export type * from "./types.js";
+//# sourceMappingURL=index.d.ts.map