@lebronj/pi-suite 0.1.19 → 0.1.21

package/README.md

@@ -15,12 +15,12 @@ pi install npm:pi-web-access
 Or use the bootstrap script to install Pi, configure the team OpenAI-compatible endpoint, install this suite, and set up Bun + qmd for memory search:
 
 ```bash
-curl -fsSL https://registry.npmjs.org/@lebronj/pi-suite/-/pi-suite-0.1.17.tgz | tar -xzO package/scripts/bootstrap.sh | bash
+curl -fsSL https://registry.npmjs.org/@lebronj/pi-suite/-/pi-suite-0.1.21.tgz | tar -xzO package/scripts/bootstrap.sh | bash
 ```
 
 ## What Is Included
 
-- Local extensions: autogoal, goal mode, pet, prompt URL widget, snake, TPS notifications.
+- Local extensions: autogoal, goal mode, update_plan, pet, prompt URL widget, snake, TPS notifications.
 - Prompts: changelog audit, issue analysis, PR review, review workflow, commit workflow, wrap workflow.
 - Skills: provider checklist, Pi capability reference, image-to-editable-PPT workflow.
 - Vendored package: `@jhp/pi-memory`, including qmd search, external curator service, memory/skill-draft versioning, scoped Multica agent roots, review reminders, and local memory/skill self-evolution queues.
@@ -75,6 +75,17 @@ Behavior:
 - Subagents are optional and budgeted; worker subagents must use worktree isolation.
 - Run artifacts are written under `~/.pi/agent/workflow-runs/autogoal-<run-id>/`.
 
+## Update Plan
+
+The `update_plan` tool gives Pi a Codex-style visible execution checklist for non-trivial tasks. It supports `init`, `start`, `done`, `drop`, `rm`, `append`, and `note`, shows active plan progress in the UI, and injects guidance to use it for 3+ step tasks or user-provided checklists.
+
+Useful commands:
+
+```bash
+/plan-status
+/plan-clear
+```
+
 ## Team Model Setup
 
 The bootstrap script can be run with `curl | bash`: it reads the API key from the terminal instead of stdin. It asks for an API key and writes:

package/extensions/update-plan.ts

@@ -0,0 +1,364 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+
+type PlanStatus = "pending" | "in_progress" | "completed" | "abandoned";
+
+interface PlanItem {
+	content: string;
+	status: PlanStatus;
+	notes?: string[];
+}
+
+interface PlanPhase {
+	name: string;
+	items: PlanItem[];
+}
+
+interface PlanDetails {
+	op: string;
+	phases: PlanPhase[];
+	error?: string;
+}
+
+const PLAN_TOOL_NAME = "update_plan";
+const PLAN_STATE_TYPE = "update-plan-state";
+const WIDGET_KEY = "update-plan";
+
+const PlanOp = StringEnum(["list", "init", "start", "done", "drop", "rm", "append", "note"] as const);
+
+const PlanOperation = Type.Object({
+	op: PlanOp,
+	list: Type.Optional(
+		Type.Array(
+			Type.Object({
+				phase: Type.String({ description: "Phase name" }),
+				items: Type.Array(Type.String({ description: "Task content" }), { minItems: 1 }),
+			}),
+		),
+	),
+	task: Type.Optional(Type.String({ description: "Exact task content" })),
+	phase: Type.Optional(Type.String({ description: "Exact phase name" })),
+	items: Type.Optional(Type.Array(Type.String({ description: "Task content" }), { minItems: 1 })),
+	text: Type.Optional(Type.String({ description: "Note text" })),
+});
+
+const UpdatePlanParams = Type.Object({
+	ops: Type.Array(PlanOperation, { minItems: 1, description: "Ordered plan operations" }),
+});
+
+type PlanOperationInput = {
+	op: "list" | "init" | "start" | "done" | "drop" | "rm" | "append" | "note";
+	list?: Array<{ phase: string; items: string[] }>;
+	task?: string;
+	phase?: string;
+	items?: string[];
+	text?: string;
+};
+
+type UpdatePlanInput = { ops: PlanOperationInput[] };
+
+function cloneItem(item: PlanItem): PlanItem {
+	return {
+		content: item.content,
+		status: item.status,
+		...(item.notes && item.notes.length > 0 ? { notes: [...item.notes] } : {}),
+	};
+}
+
+function clonePhases(phases: PlanPhase[]): PlanPhase[] {
+	return phases.map((phase) => ({ name: phase.name, items: phase.items.map(cloneItem) }));
+}
+
+function countItems(phases: PlanPhase[]): { total: number; done: number; open: number } {
+	let total = 0;
+	let done = 0;
+	let open = 0;
+	for (const phase of phases) {
+		for (const item of phase.items) {
+			total++;
+			if (item.status === "completed") done++;
+			if (item.status === "pending" || item.status === "in_progress") open++;
+		}
+	}
+	return { total, done, open };
+}
+
+function normalizeOpenTask(phases: PlanPhase[]): void {
+	const items = phases.flatMap((phase) => phase.items);
+	const active = items.filter((item) => item.status === "in_progress");
+	for (const item of active.slice(1)) {
+		item.status = "pending";
+	}
+	if (active.length > 0) return;
+	const next = items.find((item) => item.status === "pending");
+	if (next) next.status = "in_progress";
+}
+
+function findPhase(phases: PlanPhase[], name: string | undefined): PlanPhase | undefined {
+	if (!name) return undefined;
+	return phases.find((phase) => phase.name === name);
+}
+
+function findTask(phases: PlanPhase[], content: string | undefined): { phase: PlanPhase; item: PlanItem } | undefined {
+	if (!content) return undefined;
+	for (const phase of phases) {
+		const item = phase.items.find((candidate) => candidate.content === content);
+		if (item) return { phase, item };
+	}
+	return undefined;
+}
+
+function renderTextPlan(phases: PlanPhase[]): string {
+	if (phases.length === 0) return "No active plan.";
+	const lines: string[] = [];
+	for (const phase of phases) {
+		lines.push(`${phase.name}:`);
+		for (const item of phase.items) {
+			const marker = item.status === "completed" ? "[x]" : item.status === "abandoned" ? "[-]" : item.status === "in_progress" ? "[>]" : "[ ]";
+			lines.push(`  ${marker} ${item.content}`);
+			if (item.status === "in_progress" && item.notes && item.notes.length > 0) {
+				for (const note of item.notes.slice(-2)) lines.push(`      note: ${note}`);
+			}
+		}
+	}
+	const counts = countItems(phases);
+	lines.push(``);
+	lines.push(`${counts.done}/${counts.total} completed, ${counts.open} open`);
+	return lines.join("\n");
+}
+
+function renderWidgetLines(ctx: ExtensionContext, phases: PlanPhase[]): string[] | undefined {
+	if (phases.length === 0) return undefined;
+	const th = ctx.ui.theme;
+	const counts = countItems(phases);
+	const lines: string[] = [th.fg("accent", `Plan ${counts.done}/${counts.total}`)];
+	let shown = 0;
+	let hidden = 0;
+	for (const phase of phases) {
+		const openItems = phase.items.filter((item) => item.status === "pending" || item.status === "in_progress");
+		if (openItems.length === 0) continue;
+		if (shown >= 6) {
+			hidden += openItems.length;
+			continue;
+		}
+		lines.push(th.fg("muted", phase.name));
+		for (const item of openItems) {
+			if (shown >= 6) {
+				hidden++;
+				continue;
+			}
+			const marker = item.status === "in_progress" ? th.fg("accent", "[>]") : th.fg("muted", "[ ]");
+			lines.push(`${marker} ${item.content}`);
+			shown++;
+		}
+	}
+	if (hidden > 0) lines.push(th.fg("dim", `... ${hidden} more`));
+	if (counts.open === 0) lines.push(th.fg("success", "All plan items are closed."));
+	return lines;
+}
+
+function updatePlanUi(ctx: ExtensionContext, phases: PlanPhase[]): void {
+	if (!ctx.hasUI) return;
+	ctx.ui.setWidget(WIDGET_KEY, renderWidgetLines(ctx, phases));
+	const counts = countItems(phases);
+	ctx.ui.setStatus(WIDGET_KEY, counts.total > 0 ? ctx.ui.theme.fg("accent", `plan ${counts.done}/${counts.total}`) : undefined);
+}
+
+function applyOperation(phases: PlanPhase[], op: PlanOperationInput): string | undefined {
+	switch (op.op) {
+		case "list":
+			return undefined;
+		case "init": {
+			if (!op.list || op.list.length === 0) return "init requires list";
+			phases.splice(
+				0,
+				phases.length,
+				...op.list.map((phase) => ({
+					name: phase.phase,
+					items: phase.items.map((content, index) => ({ content, status: index === 0 && phases.length === 0 ? "in_progress" : "pending" as PlanStatus })),
+				})),
+			);
+			normalizeOpenTask(phases);
+			return undefined;
+		}
+		case "append": {
+			if (!op.phase) return "append requires phase";
+			if (!op.items || op.items.length === 0) return "append requires items";
+			let phase = findPhase(phases, op.phase);
+			if (!phase) {
+				phase = { name: op.phase, items: [] };
+				phases.push(phase);
+			}
+			phase.items.push(...op.items.map((content) => ({ content, status: "pending" as PlanStatus })));
+			normalizeOpenTask(phases);
+			return undefined;
+		}
+		case "start": {
+			const hit = findTask(phases, op.task);
+			if (!hit) return "start requires an existing task";
+			for (const phase of phases) {
+				for (const item of phase.items) {
+					if (item.status === "in_progress") item.status = "pending";
+				}
+			}
+			hit.item.status = "in_progress";
+			return undefined;
+		}
+		case "done":
+		case "drop": {
+			const status: PlanStatus = op.op === "done" ? "completed" : "abandoned";
+			if (op.task) {
+				const hit = findTask(phases, op.task);
+				if (!hit) return `${op.op} requires an existing task`;
+				hit.item.status = status;
+			} else if (op.phase) {
+				const phase = findPhase(phases, op.phase);
+				if (!phase) return `${op.op} requires an existing phase`;
+				for (const item of phase.items) item.status = status;
+			} else {
+				return `${op.op} requires task or phase`;
+			}
+			normalizeOpenTask(phases);
+			return undefined;
+		}
+		case "rm": {
+			if (!op.task && !op.phase) {
+				phases.splice(0, phases.length);
+				return undefined;
+			}
+			if (op.task) {
+				const hit = findTask(phases, op.task);
+				if (!hit) return "rm requires an existing task";
+				hit.phase.items = hit.phase.items.filter((item) => item !== hit.item);
+			} else if (op.phase) {
+				const index = phases.findIndex((phase) => phase.name === op.phase);
+				if (index < 0) return "rm requires an existing phase";
+				phases.splice(index, 1);
+			}
+			for (let i = phases.length - 1; i >= 0; i--) {
+				if (phases[i].items.length === 0) phases.splice(i, 1);
+			}
+			normalizeOpenTask(phases);
+			return undefined;
+		}
+		case "note": {
+			if (!op.text) return "note requires text";
+			const hit = findTask(phases, op.task);
+			if (!hit) return "note requires an existing task";
+			hit.item.notes = [...(hit.item.notes ?? []), op.text];
+			return undefined;
+		}
+	}
+}
+
+export default function updatePlanExtension(pi: ExtensionAPI): void {
+	let phases: PlanPhase[] = [];
+
+	function restoreFromEntries(ctx: ExtensionContext): void {
+		phases = [];
+		for (const entry of ctx.sessionManager.getBranch()) {
+			if (entry.type === "custom" && entry.customType === PLAN_STATE_TYPE) {
+				const data = entry.data as { phases?: PlanPhase[] } | undefined;
+				if (data?.phases) phases = clonePhases(data.phases);
+				continue;
+			}
+			if (entry.type !== "message") continue;
+			const message = entry.message as { role?: string; toolName?: string; details?: unknown; isError?: boolean };
+			if (message.role !== "toolResult" || message.toolName !== PLAN_TOOL_NAME || message.isError) continue;
+			const details = message.details as PlanDetails | undefined;
+			if (details?.phases) phases = clonePhases(details.phases);
+		}
+		updatePlanUi(ctx, phases);
+	}
+
+	pi.on("session_start", async (_event, ctx) => restoreFromEntries(ctx));
+	pi.on("session_tree", async (_event, ctx) => restoreFromEntries(ctx));
+
+	pi.on("before_agent_start", async () => {
+		if (!pi.getActiveTools().includes(PLAN_TOOL_NAME)) return;
+		return {
+			message: {
+				customType: "update-plan-guidance",
+				content: `<update_plan_guidance>\nFor non-trivial tasks with 3+ distinct steps, or when the user provides a checklist/plan, call update_plan before implementation. Keep exactly one open task in_progress, update it immediately after each completed step, and do not use update_plan for trivial one-step requests.\n</update_plan_guidance>`,
+				display: false,
+			},
+		};
+	});
+
+	pi.registerTool({
+		name: PLAN_TOOL_NAME,
+		label: "Update Plan",
+		description:
+			"Maintain a visible execution plan. Use for multi-step tasks: init the plan, mark exactly one task in_progress, and mark tasks done/drop as work proceeds.",
+		promptSnippet: "Maintain a visible execution plan for non-trivial multi-step tasks.",
+		promptGuidelines: [
+			"For tasks with 3+ distinct steps, or when the user provides a checklist, call update_plan with init before doing the work.",
+			"Keep exactly one open task in_progress; mark tasks done immediately after completing them.",
+			"Do not use update_plan for trivial single-step requests.",
+		],
+		parameters: UpdatePlanParams,
+		executionMode: "sequential",
+		async execute(_toolCallId, params: UpdatePlanInput, _signal, _onUpdate, ctx) {
+			let error: string | undefined;
+			for (const op of params.ops) {
+				error = applyOperation(phases, op);
+				if (error) break;
+			}
+			updatePlanUi(ctx, phases);
+			const lastOp = params.ops[params.ops.length - 1]?.op ?? "list";
+			const text = error ? `Error: ${error}` : renderTextPlan(phases);
+			return {
+				content: [{ type: "text", text }],
+				details: { op: lastOp, phases: clonePhases(phases), error } satisfies PlanDetails,
+				isError: error ? true : undefined,
+			};
+		},
+		renderCall(args: UpdatePlanInput, theme: Theme) {
+			const ops = args.ops?.map((op) => op.op).join("+") || "list";
+			return new Text(`${theme.fg("toolTitle", theme.bold("update_plan"))} ${theme.fg("muted", ops)}`, 0, 0);
+		},
+		renderResult(result, { expanded }, theme: Theme) {
+			const details = result.details as PlanDetails | undefined;
+			if (!details) {
+				const block = result.content?.find((item) => item.type === "text");
+				return new Text(block?.text ?? "", 0, 0);
+			}
+			if (details.error) return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+			const snapshot = details.phases ?? [];
+			if (snapshot.length === 0) return new Text(theme.fg("dim", "No active plan"), 0, 0);
+			const counts = countItems(snapshot);
+			const lines = [theme.fg("accent", `Plan ${counts.done}/${counts.total}`)];
+			for (const phase of snapshot) {
+				lines.push(theme.fg("muted", phase.name));
+				const items = expanded ? phase.items : phase.items.slice(0, 5);
+				for (const item of items) {
+					const marker = item.status === "completed" ? theme.fg("success", "[x]") : item.status === "abandoned" ? theme.fg("dim", "[-]") : item.status === "in_progress" ? theme.fg("accent", "[>]") : theme.fg("muted", "[ ]");
+					const text = item.status === "completed" || item.status === "abandoned" ? theme.fg("dim", item.content) : item.content;
+					lines.push(`${marker} ${text}`);
+				}
+				if (!expanded && phase.items.length > items.length) lines.push(theme.fg("dim", `... ${phase.items.length - items.length} more`));
+			}
+			return new Text(lines.join("\n"), 0, 0);
+		},
+	});
+
+	pi.registerCommand("plan-status", {
+		description: "Show the current update_plan state",
+		handler: async (_args, ctx) => {
+			restoreFromEntries(ctx);
+			ctx.ui.notify(renderTextPlan(phases), "info");
+		},
+	});
+
+	pi.registerCommand("plan-clear", {
+		description: "Clear the current update_plan state",
+		handler: async (_args, ctx) => {
+			phases = [];
+			pi.appendEntry(PLAN_STATE_TYPE, { phases: [] });
+			updatePlanUi(ctx, phases);
+			ctx.ui.notify("Plan cleared.", "info");
+		},
+	});
+}

package/package.json

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

package/skills/pi-skill/SKILL.md

@@ -88,10 +88,11 @@ Curator and learning behavior:
 - Expired temporary memories go to `REVIEW.md`, not automatic deletion.
 - Quotas reset when `month` or `reset` rolls over.
 - Mutations are audited to `audit/curator.jsonl`.
-- Session shutdown may extract conservative learning candidates into `REVIEW.md`; they are not injected as normal memory and are not auto-enabled.
+- Session shutdown may extract conservative learning candidates into `REVIEW.md`; `/new` and `/fork` also run a lightweight structured-evidence pass.
 - `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.
+- Repeated or high-confidence candidates can become proposed memory promotions or proposed disabled skill drafts after `memory_curate`.
+- Skill-worthy `failure -> edit/action -> validation success` patterns become high-confidence skill candidates from structured tool evidence.
+- Skill drafts default to `auto-draft`: high-quality proposals write disabled drafts under the resolved skill draft root, but memory proposals still require approval.
 - 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.
@@ -143,12 +144,16 @@ Useful memory environment variables:
 - `PI_MEMORY_NO_SEARCH=1`: disable per-turn search injection.
 - `PI_MEMORY_SUMMARIZE_TRANSITIONS=1`: also summarize lifecycle transitions such as `/reload`.
 - `PI_MEMORY_LEARNING`: `off`, `review`, or `auto-review`.
-- `PI_MEMORY_SKILL_DRAFTS`: `off` or `review`.
+- `PI_MEMORY_SKILL_DRAFTS`: `off`, `propose`/`review`, or `auto-draft` (default).
+- `PI_MEMORY_SKILL_SEEN_THRESHOLD`: repeated medium-confidence skill candidate threshold; default `2`.
 - `PI_MEMORY_AUTO_APPROVE_MEMORY=1`: automatically approve newly created memory proposals.
 - `PI_MEMORY_AUTO_APPROVE_SKILL_DRAFTS=1`: automatically create newly proposed disabled skill drafts.
 - `PI_MEMORY_CURATOR_STARTUP_HINT=0`: hide the disabled-curator startup hint.
 - `PI_MEMORY_REVIEW_STARTUP_HINT=0`: hide pending review proposal startup hints.
 - `PI_MEMORY_REMOTE_URL` and `PI_MEMORY_REMOTE_TOKEN`: enable Multica candidate/profile/feedback upload and current-agent delivery pull.
+- Local CLI Pi can bind to Multica by setting `MULTICA_WORKSPACE_ID`, `MULTICA_AGENT_ID`, `PI_MEMORY_REMOTE_URL`, and `PI_MEMORY_REMOTE_TOKEN`; it then uses the same agent root/sync loop as a Multica-wrapped Pi agent.
+- `PI_MEMORY_AUTO_SYNC=1`: best-effort automatic pull on session start and upload on session shutdown; narrower aliases are `PI_MEMORY_AUTO_SYNC_PULL_ON_START=1`, `PI_MEMORY_AUTO_SYNC_PULL=1`, `PI_MEMORY_AUTO_SYNC_UPLOAD_ON_SHUTDOWN=1`, and `PI_MEMORY_AUTO_SYNC_UPLOAD=1`.
+- `PI_MEMORY_AUTO_SYNC_PULL_LIMIT`: maximum automatic delivery pull count; default `20`.
 - `PI_EVOLUTION_ENABLED=0`: disable snapshot + git versioning.
 - `PI_EVOLUTION_DIR`: override evolution repo directory; default `~/.pi/agent/evolution`.
 - `PI_EVOLUTION_REMOTE`: optional personal private Git remote; unset by default.
@@ -221,6 +226,16 @@ Goal mode is provided by `goal-mode.ts`.
 - The agent must verify current files/checks before calling `goal({ op: "complete" })`.
 - Useful commands: `/goal show`, `/goal pause`, `/goal resume`, `/goal drop`, `/goal budget <tokens|off>`, `/goal auto on`, `/goal auto off`.
 
+## Update Plan
+
+`update-plan.ts` provides a lightweight Codex-style execution checklist without changing Pi core.
+
+- Tool: `update_plan`.
+- Use it for non-trivial tasks with 3+ distinct steps, user-provided checklists, or explicit plan/progress tracking requests.
+- Operations: `list`, `init`, `start`, `done`, `drop`, `rm`, `append`, and `note`.
+- It keeps phased task state in session history, auto-promotes the next pending task to `in_progress`, and shows widget/footer progress when active.
+- Commands: `/plan-status` shows the current plan; `/plan-clear` clears it.
+
 ## Pet Companion
 
 The pet extension provides a small terminal companion and durable profile.
@@ -233,6 +248,7 @@ The pet extension provides a small terminal companion and durable profile.
 
 ## UI And Utility Extensions
 
+- `update-plan.ts`: registers `update_plan`, `/plan-status`, and `/plan-clear` for visible per-session execution planning.
 - `prompt-url-widget.ts`: detects PR/issue prompt templates, fetches GitHub metadata with `gh`, shows a widget, and names the session when possible.
 - `snake.ts`: `/snake` opens a TUI snake game; `Esc` pauses/saves, `q` quits, arrows/WASD move.
 - `tps.ts`: after each assistant run, shows tokens-per-second and token usage details.

package/vendor/pi-memory/README.md

@@ -161,7 +161,7 @@ The curator deliberately avoids semantic auto-delete or semantic auto-merge in t
 
 ## Review-First Learning
 
-Session shutdown may extract conservative learning candidates from the recent conversation text. Candidates are written only to `REVIEW.md`; they are not injected as normal context, not written to long-term memory, and not enabled as skills.
+Session shutdown may extract conservative learning candidates from the recent conversation text, and `/new` or `/fork` transitions run a lightweight structured-evidence pass. Candidates are written only to `REVIEW.md`; they are not injected as normal context, not written to long-term memory, and not enabled as skills.
 
 Candidate examples:
 
@@ -182,7 +182,7 @@ When candidates repeat, pi-memory updates the existing candidate instead of appe
 `memory_curate` can turn stable candidates into proposals:
 
 - `kind:memory_promotion status:proposed` for durable preferences, project facts, or concise lessons.
-- `kind:skill_promotion status:proposed` for repeated skill-worthy methods.
+- `kind:skill_promotion status:proposed` for repeated or high-confidence skill-worthy methods.
 
 Approval is explicit by default:
 
@@ -191,7 +191,7 @@ Approval is explicit by default:
 - `/memory-review` lists pending proposals and supports `show <id>`, `approve <id>`, `reject <id>`, and `archive <id>` for the current resolved root.
 - `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.
+- Skill drafts are disabled. In the default `PI_MEMORY_SKILL_DRAFTS=auto-draft` mode, high-quality proposals are written to the draft root automatically, but they are not moved into enabled skill directories.
 - `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.
@@ -199,7 +199,7 @@ Approval is explicit by default:
 
 Old candidates are lifecycle-managed without deletion. Low-confidence candidates can become `archived`; others become `needs_review` first. `REVIEW.md` remains the evidence and audit trail, so approved items are marked rather than removed.
 
-Current learning extraction is text-based: it reads user/assistant conversation messages and asks the active model for structured candidates. It does not yet inspect structured tool-call graphs directly. Curator patch audit remains in `audit/curator.jsonl`; learning approvals are tracked through `REVIEW.md` proposal metadata and status changes.
+Learning extraction combines text-based model extraction with a lightweight structured tool-evidence pass. The structured pass looks for `failure -> edit/action -> validation success` patterns and emits high-confidence skill candidates. Curator patch audit remains in `audit/curator.jsonl`; learning approvals are tracked through `REVIEW.md` proposal metadata and status changes.
 
 ## Local Multi-Agent Self-Evolution
 
@@ -225,6 +225,10 @@ The package includes local primitives for the full local loop:
 
 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.
 
+Local CLI Pi agents can participate in the same Multica loop as hosted/wrapped agents. Bind the local run to a Multica identity by setting `MULTICA_WORKSPACE_ID`, `MULTICA_AGENT_ID`, `PI_MEMORY_REMOTE_URL`, and `PI_MEMORY_REMOTE_TOKEN` before launching pi. Optionally set `PI_AGENT_ROOT` to choose the exact local agent root; otherwise the package derives `~/multica_workspaces/<workspace_id>/.pi/agents/<agent_id>/`. With that identity, local Pi can manually call `memory_sync_pull` / `memory_sync_upload`, or enable the env-gated automatic fallback below.
+
+Automatic sync is off by default. Set `PI_MEMORY_AUTO_SYNC_PULL_ON_START=1` (or `PI_MEMORY_AUTO_SYNC_PULL=1`) to pull current-agent deliveries during `session_start`. Set `PI_MEMORY_AUTO_SYNC_UPLOAD_ON_SHUTDOWN=1` (or `PI_MEMORY_AUTO_SYNC_UPLOAD=1`) to upload candidates, profiles, and feedback during `session_shutdown`. `PI_MEMORY_AUTO_SYNC=1` enables both. These best-effort hooks never block startup/shutdown on sync errors.
+
 ### Local Curator Manager Service
 
 The manager service is separate from the standalone daily memory curator. It runs `jhp-pi-memory-curator manager-scan` against the registry and only processes roots marked `dirty`; when there are no dirty roots it exits after a cheap registry check.
@@ -284,9 +288,16 @@ The controller uses a systemd user timer when available and falls back to cron.
 | `PI_MEMORY_SUMMARIZE_TRANSITIONS` | `1`, `true`, `yes`, `on` | unset | Also summarize lifecycle transitions |
 | `PI_MEMORY_LEARNING` | `off`, `review`, `auto-review` | `review` | Control session learning candidate extraction |
 | `PI_MEMORY_LEARNING_MIN_CONFIDENCE` | `low`, `medium`, `high` | `medium` | Minimum extractor confidence to keep |
-| `PI_MEMORY_SKILL_DRAFTS` | `off`, `review` | `review` | Allow curator to propose disabled skill drafts |
+| `PI_MEMORY_SKILL_DRAFTS` | `off`, `propose`/`review`, `auto-draft` | `auto-draft` | Control disabled skill draft creation; `propose` only writes proposals, `auto-draft` writes disabled drafts |
+| `PI_MEMORY_SKILL_SEEN_THRESHOLD` | positive integer | `2` | Repeated medium-confidence skill candidate threshold |
 | `PI_MEMORY_AUTO_APPROVE_MEMORY` | `1`, `true`, `yes`, `on` | unset | YOLO mode for approving newly created memory proposals |
 | `PI_MEMORY_AUTO_APPROVE_SKILL_DRAFTS` | `1`, `true`, `yes`, `on` | unset | YOLO mode for creating newly proposed disabled skill drafts |
+| `PI_MEMORY_REMOTE_URL` | URL | unset | Multica evolution sync endpoint for upload/pull |
+| `PI_MEMORY_REMOTE_TOKEN` | token | unset | Bearer token for Multica evolution sync |
+| `PI_MEMORY_AUTO_SYNC` | `1`, `true`, `yes`, `on` | unset | Enable best-effort pull on start and upload on shutdown |
+| `PI_MEMORY_AUTO_SYNC_PULL` / `PI_MEMORY_AUTO_SYNC_PULL_ON_START` | `1`, `true`, `yes`, `on` | unset | Best-effort `syncPull()` during session start |
+| `PI_MEMORY_AUTO_SYNC_UPLOAD` / `PI_MEMORY_AUTO_SYNC_UPLOAD_ON_SHUTDOWN` | `1`, `true`, `yes`, `on` | unset | Best-effort `syncUpload()` during session shutdown |
+| `PI_MEMORY_AUTO_SYNC_PULL_LIMIT` | positive integer | `20` | Maximum deliveries for automatic pull |
 
 ## Development
 

package/vendor/pi-memory/index.ts

@@ -45,6 +45,7 @@ import {
 	REVIEW_CANDIDATE_KINDS,
 	REVIEW_CONFIDENCES,
 	REVIEW_TARGET_HINTS,
+	parseReviewCandidate,
 	upsertReviewCandidate,
 	type ReviewCandidateInput,
 } from "./src/learning/candidates.ts";
@@ -53,7 +54,7 @@ import { generateShareCandidatesFromReview } from "./src/governance/share-candid
 import { compactProcessedReviewEntries } from "./src/learning/review-compact.ts";
 import { countPendingReviewItems, formatPendingReviewList, formatPendingReviewSummary, listPendingReviewItems } from "./src/learning/review-summary.ts";
 import { defaultRegistryPath, markCurrentRootDirty, scanDirtyRoots } from "./src/manager/local-curator-manager.ts";
-import { approveSkillDraft, listSkillDraftProposals, proposeSkillDrafts } from "./src/learning/skills.ts";
+import { approvePendingSkillDrafts, approveSkillDraft, listSkillDraftProposals, proposeSkillDrafts } from "./src/learning/skills.ts";
 import { disableMemorySkill, enableMemorySkill, formatEnabledSkillsForPrompt, formatSkillList, listMemorySkills } from "./src/skills/lifecycle.ts";
 import { generateProfiles } from "./src/profile/generator.ts";
 import { syncPull, syncUpload } from "./src/sync/connector.ts";
@@ -585,8 +586,16 @@ export function getMemoryLearningMode(env: MemoryEnv = process.env): "off" | "re
 	return value === "off" || value === "auto-review" ? value : "review";
 }
 
-export function getMemorySkillDraftsMode(env: MemoryEnv = process.env): "off" | "review" {
-	return env.PI_MEMORY_SKILL_DRAFTS?.toLowerCase() === "off" ? "off" : "review";
+export function getMemorySkillDraftsMode(env: MemoryEnv = process.env): "off" | "propose" | "auto-draft" {
+	const value = (env.PI_MEMORY_SKILL_DRAFTS || "auto-draft").toLowerCase();
+	if (value === "off") return "off";
+	if (value === "propose" || value === "review") return "propose";
+	return "auto-draft";
+}
+
+function getMemorySkillSeenThreshold(env: MemoryEnv = process.env): number {
+	const value = Number.parseInt(env.PI_MEMORY_SKILL_SEEN_THRESHOLD || "2", 10);
+	return Number.isFinite(value) && value > 0 ? value : 2;
 }
 
 function getMemoryLearningMinConfidence(env: MemoryEnv = process.env): "low" | "medium" | "high" {
@@ -602,6 +611,51 @@ function getMemoryAutoApproveSkillDrafts(env: MemoryEnv = process.env): boolean
 	return ["1", "true", "yes", "on"].includes((env.PI_MEMORY_AUTO_APPROVE_SKILL_DRAFTS || "").toLowerCase());
 }
 
+function envFlag(env: MemoryEnv, name: string): boolean | undefined {
+	const value = env[name]?.trim().toLowerCase();
+	if (!value) return undefined;
+	if (["1", "true", "yes", "on"].includes(value)) return true;
+	if (["0", "false", "no", "off"].includes(value)) return false;
+	return undefined;
+}
+
+export function getMemoryAutoSyncPullOnStart(env: MemoryEnv = process.env): boolean {
+	return envFlag(env, "PI_MEMORY_AUTO_SYNC_PULL_ON_START")
+		?? envFlag(env, "PI_MEMORY_AUTO_SYNC_PULL")
+		?? envFlag(env, "PI_MEMORY_AUTO_SYNC")
+		?? false;
+}
+
+export function getMemoryAutoSyncUploadOnShutdown(env: MemoryEnv = process.env): boolean {
+	return envFlag(env, "PI_MEMORY_AUTO_SYNC_UPLOAD_ON_SHUTDOWN")
+		?? envFlag(env, "PI_MEMORY_AUTO_SYNC_UPLOAD")
+		?? envFlag(env, "PI_MEMORY_AUTO_SYNC")
+		?? false;
+}
+
+function getMemoryAutoSyncPullLimit(env: MemoryEnv = process.env): number {
+	const value = Number.parseInt(env.PI_MEMORY_AUTO_SYNC_PULL_LIMIT || "20", 10);
+	return Number.isFinite(value) && value > 0 ? value : 20;
+}
+
+async function runAutoSyncPullBestEffort(): Promise<void> {
+	if (!getMemoryAutoSyncPullOnStart()) return;
+	try {
+		await syncPull(process.env, getMemoryAutoSyncPullLimit());
+	} catch {
+		// Automatic sync is a Multica/local-agent convenience; never block startup.
+	}
+}
+
+async function runAutoSyncUploadBestEffort(): Promise<void> {
+	if (!getMemoryAutoSyncUploadOnShutdown()) return;
+	try {
+		await syncUpload();
+	} catch {
+		// Automatic sync is a Multica/local-agent convenience; never block shutdown.
+	}
+}
+
 function confidenceRank(confidence: "low" | "medium" | "high"): number {
 	return confidence === "low" ? 0 : confidence === "medium" ? 1 : 2;
 }
@@ -615,6 +669,7 @@ function buildLearningExtractorPrompt(conversationText: string, truncated: boole
 		"Extract zero or more review candidates from this session transcript.",
 		"Return JSON exactly shaped as: {\"candidates\":[{\"kind\":\"bug_fix|skill_candidate|preference|project_fact\",\"confidence\":\"low|medium|high\",\"signature\":\"short stable signature\",\"summary\":\"optional concise summary\",\"targetHints\":[\"memory\",\"skill\"],\"evidence\":\"optional compact evidence\"}]}",
 		"Only include verified bug fixes when a failure was followed by an edit/action and successful validation.",
+		"For skill candidates, prefer reusable methods with clear trigger signals, steps, validation signals, and stop/avoid conditions.",
 		"Drop one-off trivia, transient status, workflow artifacts, and loop artifacts.",
 	];
 	if (truncated) lines.push(`Transcript was truncated to the most recent ${conversationText.length} of ${totalChars} characters.`);
@@ -683,7 +738,7 @@ function serializeSessionConversation(branch: SessionEntry[]): { text: string; h
 	return { text: serializeConversation(convertToLlm(messages)), hasMessages: true };
 }
 
-export function parseLearningExtractorResponse(raw: string): ReviewCandidateInput[] {
+export function parseLearningExtractorResponse(raw: string, source = "session_shutdown"): ReviewCandidateInput[] {
 	let parsed: unknown;
 	try {
 		parsed = JSON.parse(raw.trim());
@@ -713,40 +768,194 @@ export function parseLearningExtractorResponse(raw: string): ReviewCandidateInpu
 			summary: typeof record.summary === "string" ? record.summary.trim() : undefined,
 			targetHints,
 			evidence: typeof record.evidence === "string" ? record.evidence.trim() : undefined,
-			source: "session_shutdown",
+			source,
 		});
 	}
 	return candidates;
 }
 
-async function runSessionLearningExtractor(ctx: ExtensionContext): Promise<number> {
+
+type ToolCallInfo = {
+	name: string;
+	arguments?: Record<string, unknown>;
+};
+
+type StructuredFailure = {
+	summary: string;
+	signature: string;
+	toolName: string;
+};
+
+function countReviewCandidates(reviewText: string): { total: number; skill: number } {
+	const entries = reviewText.split(ENTRY_DELIMITER).map((entry) => entry.trim()).filter(Boolean);
+	let total = 0;
+	let skill = 0;
+	for (const entry of entries) {
+		const candidate = parseReviewCandidate(entry);
+		if (!candidate) continue;
+		total += 1;
+		if (candidate.kind === "skill_candidate" || candidate.targetHints.includes("skill")) skill += 1;
+	}
+	return { total, skill };
+}
+
+function collectToolCalls(branch: SessionEntry[]): Map<string, ToolCallInfo> {
+	const calls = new Map<string, ToolCallInfo>();
+	for (const entry of branch) {
+		if (entry.type !== "message") continue;
+		const message = entry.message as Message;
+		if (message.role !== "assistant") continue;
+		for (const part of message.content) {
+			const candidate = part as { type?: string; id?: string; name?: string; arguments?: Record<string, unknown> };
+			if (candidate.type !== "toolCall" || !candidate.id || !candidate.name) continue;
+			calls.set(candidate.id, { name: candidate.name, arguments: candidate.arguments });
+		}
+	}
+	return calls;
+}
+
+function getToolArgumentText(args: Record<string, unknown> | undefined, key: string): string {
+	const value = args?.[key];
+	return typeof value === "string" ? value : "";
+}
+
+function summarizeToolText(text: string): string {
+	const line = text
+		.split("\n")
+		.map((candidate) => candidate.trim())
+		.find((candidate) => candidate && !candidate.startsWith("{"));
+	return previewMessageText(line || text);
+}
+
+function isFailureToolResult(message: Message, text: string): boolean {
+	if (message.role !== "toolResult") return false;
+	if (message.isError) return true;
+	return /\b(Command exited with code [1-9]|failed|failure|error|exception|traceback|diagnostics?:\s*(?!ok)|ERR_[A-Z0-9_]+)\b/i.test(text);
+}
+
+function isEditOrActionTool(toolName: string, args: Record<string, unknown> | undefined): boolean {
+	if (["edit", "write", "memory_write", "memory_edit", "lsp"].includes(toolName)) return true;
+	if (toolName !== "bash") return false;
+	const command = getToolArgumentText(args, "command");
+	return /\b(apply_patch|python3?|node|perl|sed\s+-i|mv\s+|cp\s+|npm\s+install|pnpm\s+|bun\s+|cat\s+>|tee\s+)\b/.test(command);
+}
+
+function isValidationToolSuccess(toolName: string, args: Record<string, unknown> | undefined, text: string): boolean {
+	if (toolName === "lsp") return /diagnostics.*ok|\bOK\b/i.test(text);
+	if (toolName !== "bash") return false;
+	const command = getToolArgumentText(args, "command");
+	return /\b(test|typecheck|lint|check|tsc|build|pytest|go\s+test|cargo\s+test|mvn\s+test|gradle\b|npm\s+run|pnpm\s+(test|run|--filter))\b/i.test(command);
+}
+
+function toolLabel(toolName: string, args: Record<string, unknown> | undefined): string {
+	if (toolName === "bash") return previewMessageText(getToolArgumentText(args, "command")) || "bash";
+	if (toolName === "lsp") return `lsp ${getToolArgumentText(args, "action")}`.trim();
+	return toolName;
+}
+
+export function extractStructuredToolEvidenceCandidates(branch: SessionEntry[], source = "tool_evidence"): ReviewCandidateInput[] {
+	const calls = collectToolCalls(branch);
+	const candidates: ReviewCandidateInput[] = [];
+	const emitted = new Set<string>();
+	let failure: StructuredFailure | null = null;
+	let actionAfterFailure = false;
+	let actionLabel = "";
+
+	for (const entry of branch) {
+		if (entry.type !== "message") continue;
+		const message = entry.message as Message;
+		if (message.role !== "toolResult") continue;
+		const info = calls.get(message.toolCallId);
+		const toolName = message.toolName || info?.name || "tool";
+		const args = info?.arguments;
+		const text = getMessageText(message);
+
+		if (isFailureToolResult(message, text)) {
+			const summary = summarizeToolText(text);
+			failure = {
+				summary,
+				signature: `${toolName} ${summary}`.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().slice(0, 96) || toolName,
+				toolName,
+			};
+			actionAfterFailure = false;
+			actionLabel = "";
+			continue;
+		}
+
+		if (!failure) continue;
+		if (isEditOrActionTool(toolName, args)) {
+			actionAfterFailure = true;
+			actionLabel = toolLabel(toolName, args);
+			continue;
+		}
+		if (!actionAfterFailure || !isValidationToolSuccess(toolName, args, text)) continue;
+
+		const validation = toolLabel(toolName, args);
+		const signature = `fix ${failure.signature} validated by ${validation}`.slice(0, 120);
+		if (!emitted.has(signature)) {
+			emitted.add(signature);
+			candidates.push({
+				kind: "skill_candidate",
+				confidence: "high",
+				signature,
+				summary: `Use a failure -> edit/action -> validation loop: inspect ${failure.toolName} failure, apply ${actionLabel || "the smallest relevant fix"}, then rerun ${validation}.`,
+				targetHints: ["skill"],
+				evidence: `Failure: ${failure.summary}; action: ${actionLabel || "edit/action"}; validation: ${validation}.`,
+				source,
+			});
+		}
+		failure = null;
+		actionAfterFailure = false;
+		actionLabel = "";
+		if (candidates.length >= 3) break;
+	}
+
+	return candidates;
+}
+
+async function writeLearningCandidates(candidates: ReviewCandidateInput[]): Promise<number> {
+	if (candidates.length === 0) return 0;
+	let written = 0;
+	const store = new FileMemoryStore(MEMORY_DIR);
+	for (const candidate of candidates) {
+		const result = await upsertReviewCandidate(store, candidate);
+		if (result.changed) written += 1;
+	}
+	return written;
+}
+
+async function runSessionLearningExtractor(
+	ctx: ExtensionContext,
+	options: { source?: string; includeModel?: boolean; includeStructured?: boolean } = {},
+): Promise<number> {
 	if (getMemoryLearningMode() === "off") return 0;
 	const branch = getSessionBranch(ctx);
-	if (!branch || !ctx.model) return 0;
-	const apiKey = await resolveExitSummaryApiKey(ctx);
-	if (!apiKey) return 0;
-	const conversation = serializeSessionConversation(branch);
-	if (!conversation.hasMessages || !conversation.text.trim()) return 0;
-	const truncated = truncateText(conversation.text.trim(), LEARNING_EXTRACTOR_MAX_CHARS, "end");
-	const messages: Message[] = [{
-		role: "user",
-		content: [{ type: "text", text: buildLearningExtractorPrompt(truncated.text, truncated.truncated, conversation.text.trim().length) }],
-		timestamp: Date.now(),
-	}];
-	try {
-		const response = await complete(ctx.model, { systemPrompt: LEARNING_EXTRACTOR_SYSTEM_PROMPT, messages }, { apiKey, reasoningEffort: "low" });
-		const raw = response.content.filter((part): part is { type: "text"; text: string } => part.type === "text").map((part) => part.text).join("\n");
-		const candidates = parseLearningExtractorResponse(raw);
-		let written = 0;
-		const store = new FileMemoryStore(MEMORY_DIR);
-		for (const candidate of candidates) {
-			const result = await upsertReviewCandidate(store, candidate);
-			if (result.changed) written += 1;
+	if (!branch) return 0;
+	const source = options.source || "session_shutdown";
+	const candidates: ReviewCandidateInput[] = [];
+	if (options.includeStructured !== false) {
+		candidates.push(...extractStructuredToolEvidenceCandidates(branch, source));
+	}
+	if (options.includeModel !== false && ctx.model) {
+		const apiKey = await resolveExitSummaryApiKey(ctx);
+		const conversation = serializeSessionConversation(branch);
+		if (apiKey && conversation.hasMessages && conversation.text.trim()) {
+			const truncated = truncateText(conversation.text.trim(), LEARNING_EXTRACTOR_MAX_CHARS, "end");
+			const messages: Message[] = [{
+				role: "user",
+				content: [{ type: "text", text: buildLearningExtractorPrompt(truncated.text, truncated.truncated, conversation.text.trim().length) }],
+				timestamp: Date.now(),
+			}];
+			try {
+				const response = await complete(ctx.model, { systemPrompt: LEARNING_EXTRACTOR_SYSTEM_PROMPT, messages }, { apiKey, reasoningEffort: "low" });
+				const raw = response.content.filter((part): part is { type: "text"; text: string } => part.type === "text").map((part) => part.text).join("\n");
+				candidates.push(...parseLearningExtractorResponse(raw, source));
+			} catch {
+				// Learning is best-effort and must not block session transitions.
+			}
 		}
-		return written;
-	} catch {
-		return 0;
 	}
+	return writeLearningCandidates(candidates);
 }
 
 async function generateExitSummary(ctx: ExtensionContext): Promise<ExitSummaryResult> {
@@ -1560,7 +1769,8 @@ async function runCurator(reason: string): Promise<string> {
 	});
 	const lifecycleResult = await applyReviewLifecycle(store);
 	const memoryResult = await proposeMemoryPromotions(store);
-	const skillResult = getMemorySkillDraftsMode() === "off" ? { created: 0, proposals: [] } : await proposeSkillDrafts(store, { draftsDir: SKILL_DRAFTS_DIR });
+	const skillDraftMode = getMemorySkillDraftsMode();
+	const skillResult = skillDraftMode === "off" ? { created: 0, proposals: [] } : await proposeSkillDrafts(store, { draftsDir: SKILL_DRAFTS_DIR, seenThreshold: getMemorySkillSeenThreshold() });
 	let autoApprovedMemory = 0;
 	let autoApprovedSkills = 0;
 	if (getMemoryAutoApproveMemory()) {
@@ -1569,11 +1779,8 @@ async function runCurator(reason: string): Promise<string> {
 			autoApprovedMemory += 1;
 		}
 	}
-	if (getMemoryAutoApproveSkillDrafts()) {
-		for (const proposal of skillResult.proposals) {
-			await approveSkillDraft(store, proposal.id);
-			autoApprovedSkills += 1;
-		}
+	if (skillDraftMode === "auto-draft" || getMemoryAutoApproveSkillDrafts()) {
+		autoApprovedSkills = (await approvePendingSkillDrafts(store, skillResult.proposals.map((proposal) => proposal.id))).length;
 	}
 	const learningChanges = lifecycleResult.changed + memoryResult.created + skillResult.created + autoApprovedMemory + autoApprovedSkills;
 	if (result.patches.length > 0 || learningChanges > 0) {
@@ -1622,6 +1829,7 @@ export default function (pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		refreshResolvedDirsFromEnv();
 		ensureDirs();
+		await runAutoSyncPullBestEffort();
 		exitSummaryReason = null;
 		if (terminalInputUnsubscribe) {
 			terminalInputUnsubscribe();
@@ -1636,9 +1844,13 @@ export default function (pi: ExtensionAPI) {
 				return undefined;
 			});
 			if (process.env.PI_MEMORY_REVIEW_STARTUP_HINT !== "0") {
-				const pending = countPendingReviewItems(readFileSafe(REVIEW_FILE) ?? "");
-				if (pending.total > 0) {
-					ctx.ui.notify(`Memory review: ${pending.memory} memory / ${pending.skill} skill proposals pending. Run /memory-review.`, "info");
+				const reviewText = readFileSafe(REVIEW_FILE) ?? "";
+				const pending = countPendingReviewItems(reviewText);
+				const candidates = countReviewCandidates(reviewText);
+				const skills = listMemorySkills(process.env);
+				const hasWork = pending.total > 0 || candidates.total > 0 || skills.drafts.length > 0 || skills.generated.length > 0 || skills.enabled.length > 0;
+				if (hasWork) {
+					ctx.ui.notify(`Memory review: ${candidates.total} candidate(s) (${candidates.skill} skill), ${pending.memory} memory proposal(s), ${pending.skill} skill proposal(s), ${skills.drafts.length} draft(s), ${skills.generated.length} generated, ${skills.enabled.length} enabled. Run /memory-review or /memory-skill.`, "info");
 				}
 			}
 		}
@@ -1678,8 +1890,11 @@ export default function (pi: ExtensionAPI) {
 			try {
 				if (shouldWriteTransitionHandoffForReason(shutdownReason)) {
 					await writeTransitionHandoff(ctx, shutdownReason);
+					await runSessionLearningExtractor(ctx, { source: `transition_${shutdownReason}`, includeModel: false, includeStructured: true });
+					if (getMemorySkillDraftsMode() === "auto-draft") await runCurator(`transition_${shutdownReason}`);
 				}
 			} finally {
+				await runAutoSyncUploadBestEffort();
 				exitSummaryReason = null;
 				if (updateTimer) {
 					clearTimeout(updateTimer);
@@ -1706,15 +1921,20 @@ export default function (pi: ExtensionAPI) {
 					const separator = existing.trim() ? "\n\n" : "";
 					fs.writeFileSync(filePath, existing + separator + entry, "utf-8");
 					const newCandidates = await runSessionLearningExtractor(ctx);
+					if (getMemorySkillDraftsMode() === "auto-draft") await runCurator("session_learning");
 					if (ctx.hasUI && process.env.PI_MEMORY_REVIEW_SESSION_SUMMARY !== "0") {
-						const pending = countPendingReviewItems(readFileSafe(REVIEW_FILE) ?? "");
-						ctx.ui.notify(`Memory learning today: ${newCandidates} new candidate(s), ${pending.memory} memory proposal(s) pending, ${pending.skill} skill proposal(s) pending.`, "info");
+						const reviewText = readFileSafe(REVIEW_FILE) ?? "";
+						const pending = countPendingReviewItems(reviewText);
+						const candidates = countReviewCandidates(reviewText);
+						const skills = listMemorySkills(process.env);
+						ctx.ui.notify(`Memory learning today: ${newCandidates} new candidate(s), ${candidates.skill} skill candidate(s), ${pending.memory} memory proposal(s), ${pending.skill} skill proposal(s), ${skills.drafts.length} draft(s).`, "info");
 					}
 					await ensureQmdAvailableForUpdate();
 					await runQmdUpdateNow();
 				}
 			}
 		} finally {
+			await runAutoSyncUploadBestEffort();
 			if (updateTimer) {
 				clearTimeout(updateTimer);
 				updateTimer = null;

package/vendor/pi-memory/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jhp/pi-memory",
-	"version": "0.3.14",
+	"version": "0.3.15",
 	"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/index.ts

@@ -44,6 +44,7 @@ export { appendFeedbackEvent, buildFeedbackEvent } from "./sync/feedback.ts";
 export { appendEvolutionCandidate } from "./sync/queue.ts";
 export type { Delivery, EvolutionCandidate, FeedbackEvent, FeedbackEventType, EvolutionUnitType } from "./sync/schemas.ts";
 export {
+	approvePendingSkillDrafts,
 	approveSkillDraft,
 	listSkillDraftProposals,
 	proposeSkillDrafts,

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

@@ -1,4 +1,4 @@
-import { mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { parseEntry, renderEntry } from "../curator-core/metadata.ts";
 import type { MemoryStore } from "../curator-store/types.ts";
@@ -37,7 +37,7 @@ export async function proposeSkillDrafts(
 ): Promise<SkillProposalResult> {
 	const entries = await memoryStore.readEntries("review");
 	const candidates = entries.map(parseReviewCandidate).filter((candidate): candidate is ParsedReviewCandidate => candidate !== null);
-	const threshold = options.seenThreshold ?? 3;
+	const threshold = options.seenThreshold ?? 2;
 	const proposals: SkillProposal[] = [];
 	const existingProposalSources = new Set(
 		entries
@@ -68,7 +68,12 @@ export async function approveSkillDraft(memoryStore: MemoryStore, proposalId: st
 	if (!path) throw new Error(`Skill proposal '${proposalId}' has no promotes_to path.`);
 	const content = buildSkillDraftFromProposal(parsed.body);
 	mkdirSync(dirname(path), { recursive: true });
-	writeFileSync(path, content, { encoding: "utf-8", flag: "wx" });
+	if (existsSync(path)) {
+		const existing = readFileSync(path, "utf-8");
+		if (existing !== content) throw new Error(`Skill draft already exists at '${path}'.`);
+	} else {
+		writeFileSync(path, content, { encoding: "utf-8", flag: "wx" });
+	}
 	const approved = renderEntry({
 		...parsed,
 		metadata: { ...parsed.metadata, status: "approved", approved_at: new Date().toISOString() },
@@ -80,6 +85,21 @@ export async function approveSkillDraft(memoryStore: MemoryStore, proposalId: st
 	return { proposalId, path, content };
 }
 
+export async function approvePendingSkillDrafts(memoryStore: MemoryStore, proposalIds: string[] = []): Promise<SkillApprovalResult[]> {
+	const ids = new Set(proposalIds);
+	for (const entry of await memoryStore.readEntries("review")) {
+		const metadata = parseEntry(entry).metadata;
+		if (metadata.type === "review" && metadata.kind === "skill_promotion" && metadata.status === "proposed" && metadata.id) {
+			ids.add(metadata.id);
+		}
+	}
+	const results: SkillApprovalResult[] = [];
+	for (const id of ids) {
+		results.push(await approveSkillDraft(memoryStore, id));
+	}
+	return results;
+}
+
 export async function listSkillDraftProposals(memoryStore: MemoryStore): Promise<SkillProposal[]> {
 	const entries = await memoryStore.readEntries("review");
 	return entries
@@ -126,14 +146,21 @@ function createSkillProposal(candidate: ParsedReviewCandidate, draftsDir: string
 		"## When to use",
 		description,
 		"",
+		"## Trigger signals",
+		"- The task matches the repeated source evidence or error/fix pattern.",
+		"- The user wants a reusable method rather than a one-off fact.",
+		"",
 		"## Method",
 		candidate.summary || candidate.signature,
 		"",
+		"## Validation",
+		"Use the validation signal from the source evidence. If none is available, run the narrowest relevant check and report the result.",
+		"",
+		"## Stop / avoid",
+		"Stop after validation passes, or report the remaining blocker. Avoid applying this skill when the evidence is project-specific or the trigger does not match.",
+		"",
 		"## Evidence",
 		evidence,
-		"",
-		"## Stop condition",
-		"Stop after the validation signal from the source evidence passes, or report the remaining blocker.",
 		"```",
 	].join("\n");
 	return {

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

@@ -3,13 +3,13 @@ import { existsSync, mkdtempSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "node:test";
-import { FileMemoryStore, approveSkillDraft, listSkillDraftProposals, proposeSkillDrafts, upsertReviewCandidate } from "../src/index.ts";
+import { FileMemoryStore, approvePendingSkillDrafts, approveSkillDraft, listSkillDraftProposals, proposeSkillDrafts, upsertReviewCandidate } from "../src/index.ts";
 
 test("proposes skill draft from repeated skill candidate", async () => {
 	const dir = mkdtempSync(join(tmpdir(), "pi-memory-skills-"));
 	const store = new FileMemoryStore(join(dir, "memory"));
 	const draftsDir = join(dir, "skill-drafts");
-	for (const evidence of ["first pass", "second pass", "third pass"]) {
+	for (const evidence of ["first pass", "second pass"]) {
 		await upsertReviewCandidate(store, {
 			kind: "skill_candidate",
 			confidence: "medium",
@@ -49,9 +49,32 @@ test("approves skill proposal into disabled draft and marks proposal approved",
 
 	const approved = await approveSkillDraft(store, proposed.proposals[0].id);
 	assert.equal(existsSync(approved.path), true);
-	assert.match(readFileSync(approved.path, "utf-8"), /description: Use when fix non erasable typescript syntax in pi source\./);
+	const draftContent = readFileSync(approved.path, "utf-8");
+	assert.match(draftContent, /description: Use when fix non erasable typescript syntax in pi source\./);
+	assert.match(draftContent, /## Trigger signals/);
+	assert.match(draftContent, /## Validation/);
 	const proposals = await listSkillDraftProposals(store);
 	assert.equal(proposals.length, 1);
 	const review = await store.readEntries("review");
 	assert.match(review.join("\n"), /status:approved/);
 });
+
+test("auto-approves pending skill proposals into disabled drafts", async () => {
+	const dir = mkdtempSync(join(tmpdir(), "pi-memory-skills-"));
+	const store = new FileMemoryStore(join(dir, "memory"));
+	const draftsDir = join(dir, "skill-drafts");
+	await upsertReviewCandidate(store, {
+		kind: "skill_candidate",
+		confidence: "high",
+		signature: "restore pi session jsonl",
+		summary: "Resume a Pi session from a saved JSONL with pi --session.",
+		targetHints: ["skill"],
+		evidence: "User needed a repeatable session restore command.",
+	});
+	await proposeSkillDrafts(store, { draftsDir });
+
+	const approved = await approvePendingSkillDrafts(store);
+	assert.equal(approved.length, 1);
+	assert.equal(existsSync(approved[0].path), true);
+	assert.match((await store.readEntries("review")).join("\n"), /status:approved/);
+});

package/vendor/pi-memory/test/transition-handoff.test.ts

@@ -2,6 +2,9 @@ import assert from "node:assert/strict";
 import { test } from "node:test";
 import {
 	buildTransitionHandoff,
+	extractStructuredToolEvidenceCandidates,
+	getMemoryAutoSyncPullOnStart,
+	getMemoryAutoSyncUploadOnShutdown,
 	getMemoryLearningMode,
 	getMemorySkillDraftsMode,
 	parseLearningExtractorResponse,
@@ -20,6 +23,31 @@ function message(role: "user" | "assistant", text: string) {
 	};
 }
 
+function assistantToolCall(id: string, name: string, args: Record<string, unknown>) {
+	return {
+		type: "message" as const,
+		message: {
+			role: "assistant" as const,
+			content: [{ type: "toolCall" as const, id, name, arguments: args }],
+			timestamp: 0,
+		},
+	};
+}
+
+function toolResult(id: string, name: string, text: string, isError = false) {
+	return {
+		type: "message" as const,
+		message: {
+			role: "toolResult" as const,
+			toolCallId: id,
+			toolName: name,
+			content: [{ type: "text" as const, text }],
+			isError,
+			timestamp: 0,
+		},
+	};
+}
+
 function ctx(branch: ReturnType<typeof message>[]) {
 	return {
 		sessionManager: {
@@ -44,10 +72,21 @@ test("memory learning defaults to review mode", () => {
 	assert.equal(getMemoryLearningMode({}), "review");
 	assert.equal(getMemoryLearningMode({ PI_MEMORY_LEARNING: "off" }), "off");
 	assert.equal(getMemoryLearningMode({ PI_MEMORY_LEARNING: "auto-review" }), "auto-review");
-	assert.equal(getMemorySkillDraftsMode({}), "review");
+	assert.equal(getMemorySkillDraftsMode({}), "auto-draft");
+	assert.equal(getMemorySkillDraftsMode({ PI_MEMORY_SKILL_DRAFTS: "review" }), "propose");
+	assert.equal(getMemorySkillDraftsMode({ PI_MEMORY_SKILL_DRAFTS: "propose" }), "propose");
 	assert.equal(getMemorySkillDraftsMode({ PI_MEMORY_SKILL_DRAFTS: "off" }), "off");
 });
 
+test("auto sync env flags are opt-in and support aliases", () => {
+	assert.equal(getMemoryAutoSyncPullOnStart({}), false);
+	assert.equal(getMemoryAutoSyncUploadOnShutdown({}), false);
+	assert.equal(getMemoryAutoSyncPullOnStart({ PI_MEMORY_AUTO_SYNC: "1" }), true);
+	assert.equal(getMemoryAutoSyncUploadOnShutdown({ PI_MEMORY_AUTO_SYNC: "1" }), true);
+	assert.equal(getMemoryAutoSyncPullOnStart({ PI_MEMORY_AUTO_SYNC: "1", PI_MEMORY_AUTO_SYNC_PULL_ON_START: "0" }), false);
+	assert.equal(getMemoryAutoSyncUploadOnShutdown({ PI_MEMORY_AUTO_SYNC_UPLOAD: "yes" }), true);
+});
+
 test("learning extractor response accepts only valid review candidates", () => {
 	const candidates = parseLearningExtractorResponse(JSON.stringify({
 		candidates: [
@@ -68,6 +107,23 @@ test("learning extractor response accepts only valid review candidates", () => {
 	}]);
 });
 
+test("structured tool evidence creates high-confidence skill candidate", () => {
+	const candidates = extractStructuredToolEvidenceCandidates([
+		assistantToolCall("fail", "bash", { command: "npm run check" }),
+		toolResult("fail", "bash", "Command exited with code 1\nError: shrinkwrap is out of date", false),
+		assistantToolCall("edit", "edit", { path: "package-lock.json" }),
+		toolResult("edit", "edit", "Successfully replaced 1 block", false),
+		assistantToolCall("pass", "bash", { command: "npm run check" }),
+		toolResult("pass", "bash", "OK", false),
+	] as any, "tool_evidence");
+
+	assert.equal(candidates.length, 1);
+	assert.equal(candidates[0].kind, "skill_candidate");
+	assert.equal(candidates[0].confidence, "high");
+	assert.deepEqual(candidates[0].targetHints, ["skill"]);
+	assert.match(candidates[0].evidence || "", /Failure: Command exited with code 1/);
+});
+
 test("buildTransitionHandoff captures recent conversation without LLM summary", () => {
 	const handoff = buildTransitionHandoff(
 		ctx([