@lebronj/pi-suite 0.1.18 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lebronj/pi-suite",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "JHP's Pi extension suite for team coding workflows",
   "type": "module",
   "keywords": [

package/skills/pi-skill/SKILL.md

@@ -40,8 +40,9 @@ Memory files include:
 - `.curator-state.json`: last curator run state.
 - `.curator-service.json`: external curator service state.
 - `audit/curator.jsonl`: curator audit trail.
-- Resolved skill draft root `<slug>/SKILL.md`: disabled skill drafts created after explicit approval.
+- Resolved skill draft root `<slug>/SKILL.md`: disabled skill drafts created after explicit approval; skill directories may include supporting files alongside `SKILL.md`.
 - Multica agent roots also contain `inbox/`, `shared-cache/`, `skills/generated/`, `profile/`, `feedback/feedback.jsonl`, and `sync_queue/`.
+- Skill share candidates are runnable bundles: `sync_queue/skill-candidates.jsonl` is the queue/manifest, while `sync_queue/skill-candidates/<local_unit_id>/` contains `SKILL.md` plus supporting files.
 
 Memory tools:
 
@@ -55,7 +56,7 @@ Memory tools:
 - `memory_learning_reject`: reject or archive a review candidate/proposal without deleting it.
 - `memory_skill_drafts`: list proposed skill drafts.
 - `memory_skill_list`: list current-agent draft, generated, and enabled memory-managed skills.
-- `memory_skill_enable`: explicitly enable a `draft:<slug>` or `generated:<id>` skill by copying it into `skills/enabled/<skill-name>/` and auditing the action.
+- `memory_skill_enable`: explicitly enable a `draft:<slug>` or `generated:<id>` skill by copying the full skill directory into `skills/enabled/<skill-name>/` and auditing the action.
 - `memory_skill_disable`: remove an enabled skill copy while preserving its draft/generated source.
 - `/memory-skill`: slash command to list/enable/disable current-agent memory-managed skills.
 - `/memory-review`: slash command to list/show/approve/reject/archive pending memory and skill proposals in the current resolved root.
@@ -91,10 +92,11 @@ Curator and learning behavior:
 - `memory_curate` scans yesterday's daily log once per content hash into review candidates, then curator lifecycle and proposal rules process those candidates.
 - Repeated candidates can become proposed memory promotions or proposed disabled skill drafts after `memory_curate`.
 - Approval is explicit by default: memory proposals write to memory stores; skill proposals write disabled drafts under the resolved skill draft root.
-- Draft and generated skills stay disabled until `memory_skill_enable` copies them into `skills/enabled`; enabled skills are injected as `<available_skills>` metadata for the current agent.
+- Draft and generated skills stay disabled until `memory_skill_enable` copies their full directories into `skills/enabled`; enabled skills are injected as `<available_skills>` metadata for the current agent.
 - Pi session start can show one pending-review hint; disable with `PI_MEMORY_REVIEW_STARTUP_HINT=0`.
 - Local multi-agent self-evolution supports one Local Curator Manager registry/dirty-root API for many agent roots, plus a manager service that runs `manager-scan` every 6 hours and exits quickly when no root is dirty.
 - The local loop also covers share candidate queue, profile generation, sync upload/pull, downflow receive cache, generated skills, enabled skill lifecycle, and feedback JSONL helpers.
+- Skill upload/downflow follows Multica's runnable bundle shape: `content` is `SKILL.md`, `files` are supporting files, and `content_hash` covers both.
 - Server downflow is per-Agent delivery, not broadcast; local receive writes only `inbox/`, `shared-cache/`, or `skills/generated/` and never overwrites formal memory or auto-enables skills.
 - The curator avoids semantic auto-delete/merge; ambiguous learning stays in review first.
 

package/vendor/pi-memory/README.md

@@ -59,6 +59,8 @@ The extension auto-creates the `pi-memory` qmd collection and path contexts on s
   profile/user-profile.md agent-profile.md task-profile.md capability-profile.md
   feedback/feedback.jsonl
   sync_queue/memory-candidates.jsonl skill-candidates.jsonl
+  sync_queue/skill-candidates/<local_unit_id>/SKILL.md   # Runnable upload bundle
+  sync_queue/skill-candidates/<local_unit_id>/**         # Supporting files
 ```
 
 Structured entries are separated by `§` and may start with metadata:
@@ -190,7 +192,7 @@ Approval is explicit by default:
 - `memory_learning_approve` on a memory proposal writes `MEMORY.md`, `USER.md`, or `STATE.md` depending on the proposal target.
 - `memory_learning_approve` on a skill proposal writes the current resolved skill draft root and marks the proposal approved.
 - Skill drafts are disabled. They are not moved into enabled skill directories automatically.
-- `memory_skill_enable` explicitly copies a `draft:<slug>` or `generated:<id>` skill into `skills/enabled/<skill-name>/` and writes `memory/audit/skill-lifecycle.jsonl`.
+- `memory_skill_enable` explicitly copies a full `draft:<slug>` or `generated:<id>` skill directory into `skills/enabled/<skill-name>/` and writes `memory/audit/skill-lifecycle.jsonl`.
 - `memory_skill_disable` removes only the enabled copy; the draft/generated source remains for later review.
 - Enabled skills are injected as available-skill metadata so the agent can read the corresponding `SKILL.md` when the task matches.
 - `memory_learning_reject` marks a candidate or proposal as `rejected` or `archived` without deleting it.
@@ -214,11 +216,11 @@ The package includes local primitives for the full local loop:
 
 - `ensureAgentRoot()` initializes the scoped directory tree.
 - `markCurrentRootDirty()` and `scanDirtyRoots()` implement a single Local Curator Manager registry, manager-level locking, stale lock cleanup, and per-root `.curator.lock` processing.
-- `generateShareCandidatesFromReview()` and `appendEvolutionCandidate()` write governed share candidates to `sync_queue/` and block secret-like payloads.
+- `generateShareCandidatesFromReview()` and `appendEvolutionCandidate()` write governed share candidates to `sync_queue/` and block secret-like payloads. Skill candidates follow Multica's runnable bundle shape: JSONL contains queue metadata plus `content` as `SKILL.md` and `files` as supporting files, while `sync_queue/skill-candidates/<local_unit_id>/` stores the same runnable directory for inspection/upload.
 - `generateProfiles()` writes conservative local profiles for remote matching input.
 - `syncUpload()` / `memory_sync_upload` POST candidates, profiles, and feedback, using a checkpoint to avoid re-uploading prior candidate ids or feedback lines.
 - `syncPull()` / `memory_sync_pull` pull only current-agent deliveries and call `receiveDelivery()`.
-- `receiveDelivery()` writes server downflow only to `inbox/`, `shared-cache/`, or `skills/generated/`; it never overwrites formal memory or enables skills.
+- `receiveDelivery()` writes server downflow only to `inbox/`, `shared-cache/`, or `skills/generated/`; skill deliveries restore `SKILL.md` plus supporting `files`, but never overwrite formal memory or enable skills.
 - `appendFeedbackEvent()` / `memory_feedback` writes injected/used/ignored/success/failure/conflict events to `feedback/feedback.jsonl` for connector upload.
 
 Server delivery is per-agent matching, not broadcast. The local runtime must only pull deliveries for the current `MULTICA_AGENT_ID` and still filter before injection.

package/vendor/pi-memory/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jhp/pi-memory",
-	"version": "0.3.13",
+	"version": "0.3.14",
 	"description": "Pi coding agent extension for structured time-aware memory with qmd-powered search and curator support",
 	"main": "index.ts",
 	"bin": {

package/vendor/pi-memory/src/governance/share-candidates.ts

@@ -1,3 +1,5 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { parseEntry } from "../curator-core/metadata.ts";
 import type { MemoryStore } from "../curator-store/types.ts";
 import type { PiAgentEnv } from "../paths/resolve-roots.ts";
@@ -23,9 +25,17 @@ export async function generateShareCandidatesFromReview(memoryStore: MemoryStore
 		}
 		try {
 			const type = parsed.metadata.kind === "skill_promotion" || parsed.metadata.target_hints?.includes("skill") ? "skill" : "memory";
+			const sourcePath = type === "skill" ? sourceSkillDir(parsed.metadata.promotes_to) : undefined;
+			if (type === "skill" && !sourcePath) {
+				result.skipped += 1;
+				continue;
+			}
 			const appended = appendEvolutionCandidate({
 				type,
 				content,
+				name: parsed.metadata.name,
+				description: parsed.metadata.description,
+				source_path: sourcePath,
 				tags: tagsFromEntry(parsed.metadata.tags || parsed.metadata.kind || "memory"),
 				source: "local_curator",
 				suggested_scope: suggestedScope(parsed.metadata.scope),
@@ -66,6 +76,12 @@ function tagsFromEntry(value: string): string[] {
 	return value.split(/[ ,#]+/).map((tag) => tag.trim()).filter(Boolean).slice(0, 8);
 }
 
+function sourceSkillDir(promotesTo: string | undefined): string | undefined {
+	if (!promotesTo || !promotesTo.replace(/\\/g, "/").endsWith("/SKILL.md")) return undefined;
+	const dir = dirname(promotesTo);
+	return existsSync(join(dir, "SKILL.md")) ? dir : undefined;
+}
+
 function suggestedScope(value: string | undefined): "agent" | "workspace" | "project" | "team" | "global" | "agent_type" {
 	if (value === "workspace" || value === "project" || value === "team" || value === "global") return value;
 	return "workspace";

package/vendor/pi-memory/src/skills/lifecycle.ts

@@ -61,7 +61,7 @@ export function enableMemorySkill(input: string, options: { force?: boolean; env
 	if (existsSync(targetPath) && !options.force) throw new Error(`enabled skill '${source.name}' already exists; pass force to replace it`);
 	if (existsSync(targetDir)) rmSync(targetDir, { recursive: true, force: true });
 	mkdirSync(targetDir, { recursive: true });
-	writeFileSync(targetPath, readFileSync(source.path, "utf-8"), "utf-8");
+	copySkillDirectory(dirname(source.path), targetDir);
 	const manifest = {
 		name: source.name,
 		description: source.description,
@@ -166,6 +166,22 @@ function readSkillItem(skillPath: string, kind: SkillLifecycleKind, id = basenam
 	};
 }
 
+function copySkillDirectory(sourceDir: string, targetDir: string): void {
+	for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+		if (entry.isSymbolicLink() || entry.name === ENABLED_MANIFEST) continue;
+		const sourcePath = join(sourceDir, entry.name);
+		const targetPath = join(targetDir, entry.name);
+		if (entry.isDirectory()) {
+			mkdirSync(targetPath, { recursive: true });
+			copySkillDirectory(sourcePath, targetPath);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		mkdirSync(dirname(targetPath), { recursive: true });
+		writeFileSync(targetPath, readFileSync(sourcePath));
+	}
+}
+
 function parseSkillFrontmatter(content: string): SkillFrontmatter | null {
 	if (!content.startsWith("---\n")) return null;
 	const end = content.indexOf("\n---", 4);

package/vendor/pi-memory/src/sync/downflow.ts

@@ -3,6 +3,7 @@ import { dirname, join } from "node:path";
 import { resolveAgentRoots, type PiAgentEnv } from "../paths/resolve-roots.ts";
 import { detectSensitivity } from "./sensitivity.ts";
 import type { Delivery } from "./schemas.ts";
+import { validateSkillBundleFiles, writeSkillBundle } from "./skill-bundle.ts";
 
 export type ReceiveDeliveryResult = {
 	written: string[];
@@ -29,10 +30,10 @@ export function receiveDelivery(delivery: Delivery, env: PiAgentEnv = process.en
 	mkdirSync(inboxDir, { recursive: true });
 	mkdirSync(generatedDir, { recursive: true });
 	const skillContent = delivery.content.endsWith("\n") ? delivery.content : `${delivery.content}\n`;
-	writeTextIfChanged(join(inboxDir, "SKILL.md"), skillContent);
-	writeTextIfChanged(join(generatedDir, "SKILL.md"), skillContent);
+	const files = validateSkillBundleFiles(delivery.files || []);
+	written.push(...writeSkillBundle(inboxDir, skillContent, files));
+	written.push(...writeSkillBundle(generatedDir, skillContent, files));
 	writeJsonIfChanged(join(inboxDir, "delivery.json"), delivery);
-	written.push(join(inboxDir, "SKILL.md"), join(generatedDir, "SKILL.md"));
 	return { written, accepted: true };
 }
 

package/vendor/pi-memory/src/sync/queue.ts

@@ -1,9 +1,10 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
 import { createHash } from "node:crypto";
 import { resolveAgentRoots, type PiAgentEnv } from "../paths/resolve-roots.ts";
 import { detectSensitivity, redactLocalPaths } from "./sensitivity.ts";
 import type { EvolutionCandidate } from "./schemas.ts";
+import { hashSkillBundle, loadSkillBundle, writeSkillBundle } from "./skill-bundle.ts";
 
 export function appendEvolutionCandidate(input: Omit<EvolutionCandidate, "workspace_id" | "agent_id" | "local_unit_id" | "signature" | "created_at"> & Partial<Pick<EvolutionCandidate, "workspace_id" | "agent_id" | "local_unit_id" | "signature" | "created_at">>, env: PiAgentEnv = process.env): { path: string; candidate: EvolutionCandidate; appended: boolean } {
 	const roots = resolveAgentRoots(env);
@@ -11,30 +12,56 @@ export function appendEvolutionCandidate(input: Omit<EvolutionCandidate, "worksp
 	const workspaceId = input.workspace_id || roots.workspaceId;
 	const agentId = input.agent_id || roots.agentId;
 	if (!workspaceId || !agentId) throw new Error("candidate requires workspace_id and agent_id");
-	const sensitivity = input.sensitivity || detectSensitivity(input.content);
+
+	const skillBundle = input.type === "skill" && input.source_path ? loadSkillBundle(input.source_path) : null;
+	const rawContent = skillBundle?.content ?? input.content;
+	const allSkillContent = skillBundle ? [skillBundle.content, ...skillBundle.files.map((file) => file.content)].join("\n") : rawContent;
+	const sensitivity = input.sensitivity || detectSensitivity(allSkillContent);
 	if (sensitivity === "secret") throw new Error("secret-like content cannot enter sync_queue");
-	const content = sensitivity === "local_path" ? redactLocalPaths(input.content) : input.content;
-	const signature = input.signature || stableHash([input.type, content, input.tags.join(",")].join("\n"));
+	const content = sensitivity === "local_path" ? redactLocalPaths(rawContent) : rawContent;
+	const files = sensitivity === "local_path"
+		? skillBundle?.files.map((file) => ({ ...file, content: redactLocalPaths(file.content) }))
+		: skillBundle?.files;
+	const signature = input.signature || stableHash([input.type, content, files?.map((file) => `${file.path}\0${file.content}`).join("\0") || "", input.tags.join(",")].join("\n"));
+	const localUnitId = input.local_unit_id || `${input.type}_${signature.slice(0, 12)}`;
 	const candidate: EvolutionCandidate = {
 		...input,
 		workspace_id: workspaceId,
 		agent_id: agentId,
-		local_unit_id: input.local_unit_id || `${input.type}_${signature.slice(0, 12)}`,
+		local_unit_id: localUnitId,
 		signature,
 		content,
 		sensitivity,
 		created_at: input.created_at || new Date().toISOString(),
 	};
+	if (skillBundle) {
+		const bundleDir = join(roots.syncQueueDir, "skill-candidates", localUnitId);
+		const written = writeSkillBundle(bundleDir, content, files || []);
+		candidate.name = skillBundle.name;
+		candidate.description = skillBundle.description;
+		candidate.provider = skillBundle.provider;
+		candidate.content_hash = hashSkillBundle(content, files || []);
+		candidate.files = files || [];
+		candidate.bundle_path = relative(roots.syncQueueDir, bundleDir).replace(/\\/g, "/");
+		candidate.source_path = candidate.bundle_path;
+		writeCandidateManifest(join(bundleDir, "candidate.json"), candidate);
+		if (written.length === 0) throw new Error("skill bundle was not written");
+	}
 	const filePath = join(roots.syncQueueDir, input.type === "skill" ? "skill-candidates.jsonl" : "memory-candidates.jsonl");
 	mkdirSync(roots.syncQueueDir, { recursive: true });
 	if (existsSync(filePath)) {
-		const exists = readFileSync(filePath, "utf-8").split("\n").some((line) => line.includes(`\"local_unit_id\":\"${candidate.local_unit_id}\"`));
+		const exists = readFileSync(filePath, "utf-8").split("\n").some((line: string) => line.includes(`\"local_unit_id\":\"${candidate.local_unit_id}\"`));
 		if (exists) return { path: filePath, candidate, appended: false };
 	}
 	appendFileSync(filePath, `${JSON.stringify(candidate)}\n`, "utf-8");
 	return { path: filePath, candidate, appended: true };
 }
 
+function writeCandidateManifest(filePath: string, candidate: EvolutionCandidate): void {
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, `${JSON.stringify(candidate, null, 2)}\n`, "utf-8");
+}
+
 function stableHash(value: string): string {
 	return createHash("sha256").update(value).digest("hex");
 }

package/vendor/pi-memory/src/sync/schemas.ts

@@ -1,6 +1,11 @@
 export type EvolutionUnitType = "memory" | "skill" | "workflow" | "tool_pattern" | "preference";
 export type FeedbackEventType = "injected" | "used" | "ignored" | "success" | "failure" | "conflict";
 
+export type SkillFileData = {
+	path: string;
+	content: string;
+};
+
 export type EvolutionCandidate = {
 	type: EvolutionUnitType;
 	workspace_id: string;
@@ -15,6 +20,13 @@ export type EvolutionCandidate = {
 	sensitivity?: "none" | "local_path" | "personal" | "secret" | "unknown";
 	source_candidate_ids?: string[];
 	created_at: string;
+	name?: string;
+	description?: string;
+	source_path?: string;
+	provider?: "pi";
+	content_hash?: string;
+	files?: SkillFileData[];
+	bundle_path?: string;
 };
 
 export type FeedbackEvent = {
@@ -34,6 +46,12 @@ export type Delivery = {
 	shared_unit_id: string;
 	unit_type: "memory" | "skill";
 	content: string;
+	name?: string;
+	description?: string;
+	files?: SkillFileData[];
+	source_path?: string;
+	provider?: "pi";
+	content_hash?: string;
 	tags?: string[];
 	score?: number;
 	task_types?: string[];

package/vendor/pi-memory/src/sync/skill-bundle.ts

@@ -0,0 +1,150 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+
+export type SkillBundleFile = {
+	path: string;
+	content: string;
+};
+
+export type SkillBundle = {
+	name: string;
+	description: string;
+	content: string;
+	source_path: string;
+	provider: "pi";
+	content_hash: string;
+	files: SkillBundleFile[];
+};
+
+const MAX_SKILL_FILE_SIZE = 1 << 20;
+const MAX_SKILL_BUNDLE_SIZE = 8 << 20;
+const MAX_SKILL_FILE_COUNT = 128;
+
+export function loadSkillBundle(skillDir: string): SkillBundle {
+	const resolvedDir = resolve(skillDir);
+	const skillPath = join(resolvedDir, "SKILL.md");
+	if (!existsSync(skillPath)) throw new Error(`skill bundle requires SKILL.md: ${skillPath}`);
+	const content = readBoundedFile(skillPath);
+	const frontmatter = parseSkillFrontmatter(content);
+	if (!frontmatter.name) throw new Error(`skill SKILL.md must include frontmatter name: ${skillPath}`);
+	const files = collectSkillSupportingFiles(resolvedDir);
+	return {
+		name: frontmatter.name,
+		description: frontmatter.description || "",
+		content,
+		source_path: resolvedDir,
+		provider: "pi",
+		content_hash: hashSkillBundle(content, files),
+		files,
+	};
+}
+
+export function writeSkillBundle(skillDir: string, content: string, files: SkillBundleFile[] = []): string[] {
+	const resolvedDir = resolve(skillDir);
+	const written: string[] = [];
+	const mainPath = join(resolvedDir, "SKILL.md");
+	writeTextIfChanged(mainPath, content.endsWith("\n") ? content : `${content}\n`);
+	written.push(mainPath);
+	for (const file of validateSkillBundleFiles(files)) {
+		const target = join(resolvedDir, file.path);
+		writeTextIfChanged(target, file.content);
+		written.push(target);
+	}
+	return written;
+}
+
+export function validateSkillBundleFiles(files: SkillBundleFile[] = []): SkillBundleFile[] {
+	const valid: SkillBundleFile[] = [];
+	for (const file of files) {
+		const clean = normalizeSkillFilePath(file.path);
+		if (!clean) continue;
+		valid.push({ path: clean, content: String(file.content ?? "") });
+	}
+	return valid.sort((a, b) => a.path.localeCompare(b.path));
+}
+
+export function hashSkillBundle(content: string, files: SkillBundleFile[]): string {
+	const h = createHash("sha256");
+	h.update(content);
+	for (const file of validateSkillBundleFiles(files)) {
+		h.update(`\0${file.path}\0${file.content}`);
+	}
+	return `sha256:${h.digest("hex")}`;
+}
+
+function collectSkillSupportingFiles(skillDir: string): SkillBundleFile[] {
+	const files: SkillBundleFile[] = [];
+	let totalSize = 0;
+	function walk(dir: string): void {
+		for (const entry of readdirSync(dir, { withFileTypes: true })) {
+			if (entry.isSymbolicLink()) continue;
+			if (isIgnoredSkillEntry(entry.name)) continue;
+			const fullPath = join(dir, entry.name);
+			if (entry.isDirectory()) {
+				walk(fullPath);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			const rel = normalizeSkillFilePath(relative(skillDir, fullPath));
+			if (!rel) continue;
+			const info = statSync(fullPath);
+			if (info.size > MAX_SKILL_FILE_SIZE) continue;
+			if (files.length >= MAX_SKILL_FILE_COUNT) throw new Error(`local skill exceeds ${MAX_SKILL_FILE_COUNT} files`);
+			totalSize += info.size;
+			if (totalSize > MAX_SKILL_BUNDLE_SIZE) throw new Error(`local skill exceeds ${MAX_SKILL_BUNDLE_SIZE} bytes in total`);
+			files.push({ path: rel, content: readFileSync(fullPath, "utf-8") });
+		}
+	}
+	walk(skillDir);
+	return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+
+function readBoundedFile(filePath: string): string {
+	const info = statSync(filePath);
+	if (info.size > MAX_SKILL_FILE_SIZE) throw new Error(`SKILL.md exceeds ${MAX_SKILL_FILE_SIZE} bytes`);
+	return readFileSync(filePath, "utf-8");
+}
+
+function normalizeSkillFilePath(path: string): string | null {
+	const normalized = path.replace(/\\/g, "/").split("/").filter(Boolean).join("/");
+	if (!normalized || normalized === "." || normalized.startsWith("../") || normalized.includes("/../")) return null;
+	if (normalized.startsWith("/") || normalized.startsWith("~")) return null;
+	if (normalized.toLowerCase() === "skill.md") return null;
+	return normalized;
+}
+
+function isIgnoredSkillEntry(name: string): boolean {
+	if (!name || name.startsWith(".")) return true;
+	switch (name.toLowerCase()) {
+		case "skill.md":
+		case "license":
+		case "license.md":
+		case "license.txt":
+			return true;
+		default:
+			return false;
+	}
+}
+
+function parseSkillFrontmatter(content: string): { name: string; description: string } {
+	if (!content.startsWith("---\n")) return { name: "", description: "" };
+	const end = content.indexOf("\n---", 4);
+	if (end < 0) return { name: "", description: "" };
+	const result: { name: string; description: string } = { name: "", description: "" };
+	for (const line of content.slice(4, end).split("\n")) {
+		const index = line.indexOf(":");
+		if (index < 0) continue;
+		const key = line.slice(0, index).trim();
+		const value = line.slice(index + 1).trim().replace(/^["']|["']$/g, "");
+		if (key === "name") result.name = value;
+		if (key === "description") result.description = value;
+	}
+	return result;
+}
+
+function writeTextIfChanged(filePath: string, value: string): void {
+	mkdirSync(dirname(filePath), { recursive: true });
+	if (existsSync(filePath)) return;
+	writeFileSync(filePath, value, "utf-8");
+}

package/vendor/pi-memory/test/skill-lifecycle.test.ts

@@ -34,6 +34,8 @@ test("enables and disables a draft skill without deleting the draft", () => {
 	const { agentRoot, env } = agentEnv();
 	const draftDir = join(agentRoot, "skills", "drafts", "draft-one");
 	writeSkill(join(draftDir, "SKILL.md"), "draft-one");
+	mkdirSync(join(draftDir, "templates"), { recursive: true });
+	writeFileSync(join(draftDir, "templates", "prompt.md"), "supporting file\n", "utf-8");
 
 	let skills = listMemorySkills(env);
 	assert.equal(skills.drafts.length, 1);
@@ -42,6 +44,7 @@ test("enables and disables a draft skill without deleting the draft", () => {
 	const enabled = enableMemorySkill("draft:draft-one", { env });
 	assert.equal(enabled.enabled.name, "draft-one");
 	assert.equal(existsSync(join(agentRoot, "skills", "enabled", "draft-one", "SKILL.md")), true);
+	assert.equal(existsSync(join(agentRoot, "skills", "enabled", "draft-one", "templates", "prompt.md")), true);
 	assert.equal(existsSync(join(agentRoot, "skills", "drafts", "draft-one", "SKILL.md")), true);
 	assert.match(readFileSync(join(agentRoot, "memory", "audit", "skill-lifecycle.jsonl"), "utf-8"), /"action":"enable"/);
 
@@ -64,11 +67,13 @@ test("enables a generated skill delivery by generated id", () => {
 		shared_unit_id: "unit_skill_1",
 		unit_type: "skill",
 		content: "---\nname: shared-demo\ndescription: Use for tests.\n---\n# Shared Demo\n",
+		files: [{ path: "templates/prompt.md", content: "shared supporting file\n" }],
 	}, env);
 
 	const enabled = enableMemorySkill("generated:unit_skill_1", { env });
 	assert.equal(enabled.source.kind, "generated");
 	assert.equal(enabled.enabled.name, "shared-demo");
+	assert.equal(existsSync(join(agentRoot, "skills", "enabled", "shared-demo", "templates", "prompt.md")), true);
 	assert.equal(existsSync(join(agentRoot, "skills", "enabled", "shared-demo", ".pi-skill-enabled.json")), true);
 	const manifest = readFileSync(join(agentRoot, "skills", "enabled", "shared-demo", ".pi-skill-enabled.json"), "utf-8");
 	assert.match(manifest, /generated:unit_skill_1/);

package/vendor/pi-memory/test/sync-local-loop.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "node:test";
@@ -48,6 +48,33 @@ test("sync queue writes share candidates and blocks secret-like payloads", () =>
 	}, env), /secret-like content/);
 });
 
+test("skill candidates upload a runnable bundle with supporting files", () => {
+	const { agentRoot, env } = agentEnv();
+	const skillDir = join(agentRoot, "skills", "drafts", "bundle-demo");
+	mkdirSync(join(skillDir, "scripts"), { recursive: true });
+	writeFileSync(join(skillDir, "SKILL.md"), "---\nname: bundle-demo\ndescription: Use bundle demo.\n---\n# Bundle Demo\n", "utf-8");
+	writeFileSync(join(skillDir, "scripts", "run.sh"), "echo bundle\n", "utf-8");
+
+	const result = appendEvolutionCandidate({
+		type: "skill",
+		content: "fallback should be replaced by SKILL.md",
+		source_path: skillDir,
+		tags: ["coding"],
+		source: "local_curator",
+		suggested_scope: "agent_type",
+		status: "candidate",
+	}, env);
+
+	assert.equal(result.appended, true);
+	assert.equal(result.candidate.name, "bundle-demo");
+	assert.equal(result.candidate.files?.[0]?.path, "scripts/run.sh");
+	assert.match(result.candidate.content, /# Bundle Demo/);
+	assert.equal(existsSync(join(agentRoot, "sync_queue", "skill-candidates", result.candidate.local_unit_id, "SKILL.md")), true);
+	assert.equal(existsSync(join(agentRoot, "sync_queue", "skill-candidates", result.candidate.local_unit_id, "scripts", "run.sh")), true);
+	const queue = readFileSync(join(agentRoot, "sync_queue", "skill-candidates.jsonl"), "utf-8");
+	assert.match(queue, /"files":\[\{"path":"scripts\/run.sh"/);
+});
+
 test("downflow receive writes only inbox/cache/generated locations", () => {
 	const { agentRoot, env } = agentEnv();
 	const memoryResult = receiveDelivery({
@@ -67,10 +94,13 @@ test("downflow receive writes only inbox/cache/generated locations", () => {
 		shared_unit_id: "unit_skill_1",
 		unit_type: "skill",
 		content: "---\nname: shared-demo\ndescription: Use for tests.\n---\n# Shared Demo\n",
+		files: [{ path: "scripts/run.sh", content: "echo shared\n" }],
 	}, env);
 	assert.equal(skillResult.accepted, true);
 	assert.equal(existsSync(join(agentRoot, "inbox", "skills", "unit_skill_1", "SKILL.md")), true);
+	assert.equal(existsSync(join(agentRoot, "inbox", "skills", "unit_skill_1", "scripts", "run.sh")), true);
 	assert.equal(existsSync(join(agentRoot, "skills", "generated", "unit_skill_1", "SKILL.md")), true);
+	assert.equal(existsSync(join(agentRoot, "skills", "generated", "unit_skill_1", "scripts", "run.sh")), true);
 	assert.equal(existsSync(join(agentRoot, "skills", "enabled", "unit_skill_1", "SKILL.md")), false);
 });