@danypops/papyrus 0.60.6 → 0.60.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.60.6",
+  "version": "0.60.7",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "main": "./src/index.ts",

package/src/artifact/artifact-activation-audit.ts

@@ -13,6 +13,8 @@ export interface ActivationAuditEntry {
 	scopeMode: ArtifactScopeMode;
 	enabled: boolean;
 	reason: string;
+	activationEnabled: boolean;
+	labelMatch?: "any" | "all";
 	priority: number;
 	injection: InjectionProfile;
 	estimatedTokens: number;
@@ -63,7 +65,7 @@ export function auditArtifactActivation(
 				decision = { enabled: false, reason: "rule is an artifact template" };
 			} else if (artifact.kind === "rule" && !passesRuleRunScope(artifact, activeTaskId)) {
 				decision = { enabled: false, reason: "run ownership does not apply" };
-			} else decision = evaluateActivation(config, { ...context, projectRoot });
+			} else decision = evaluateActivation(config, { ...context, projectRoot }, artifact.labels);
 			return {
 				id: artifact.id,
 				kind: artifact.kind as "rule" | "playbook",
@@ -71,6 +73,8 @@ export function auditArtifactActivation(
 				status: artifact.status,
 				scopeMode: scope.mode,
 				...decision,
+				activationEnabled: config.enabled,
+				...(config.labels === undefined ? {} : { labelMatch: config.labels }),
 				priority: config.priority,
 				injection: config.injection,
 				estimatedTokens: estimatedTokens(artifacts, artifact),

package/src/artifact/artifact-activation.ts

@@ -18,6 +18,7 @@ export type ActivationField = (typeof ACTIVATION_FIELDS)[number];
 export const ACTIVATION_OPERATORS = ["eq", "in", "contains_any", "contains_all", "exists"] as const;
 export type ActivationOperator = (typeof ACTIVATION_OPERATORS)[number];
 export type InjectionProfile = "full" | "catalog" | "on-demand";
+export type ActivationLabelMatch = "any" | "all";
 
 export type ActivationPredicate =
 	| { field: ActivationField; operator: ActivationOperator; value: string | string[] | boolean }
@@ -26,7 +27,11 @@ export type ActivationPredicate =
 	| { not: ActivationPredicate };
 
 export interface ActivationConfig {
+	/** Persisted manual switch, independent of lifecycle and project scope. Missing values default true. */
+	enabled: boolean;
 	predicate?: ActivationPredicate;
+	/** Opt-in bridge to the artifact label system: compare this artifact's direct labels with the active Task's labels. */
+	labels?: ActivationLabelMatch;
 	priority: number;
 	injection: InjectionProfile;
 	invalid?: true;
@@ -144,8 +149,18 @@ function validatePredicate(value: unknown, state: ValidationState, depth: number
 
 export function validateActivationConfig(value: unknown, defaultInjection: InjectionProfile = "full"): ActivationConfig {
 	const input = record(value, "activation");
-	if (!Object.keys(input).every((key) => key === "predicate" || key === "priority" || key === "injection")) {
-		throw new Error("activation supports only predicate, priority, and injection");
+	if (
+		!Object.keys(input).every(
+			(key) => key === "enabled" || key === "predicate" || key === "labels" || key === "priority" || key === "injection",
+		)
+	) {
+		throw new Error("activation supports only enabled, predicate, labels, priority, and injection");
+	}
+	const enabled = input.enabled === undefined ? true : input.enabled;
+	if (typeof enabled !== "boolean") throw new Error("activation enabled must be a boolean");
+	const labels = input.labels;
+	if (labels !== undefined && labels !== "any" && labels !== "all") {
+		throw new Error("activation labels must be any or all");
 	}
 	const priority = input.priority === undefined ? 0 : input.priority;
 	if (!Number.isInteger(priority) || (priority as number) < -1000 || (priority as number) > 1000) {
@@ -156,21 +171,44 @@ export function validateActivationConfig(value: unknown, defaultInjection: Injec
 		throw new Error("activation injection must be full, catalog, or on-demand");
 	}
 	return {
+		enabled,
 		...(input.predicate === undefined ? {} : { predicate: validatePredicate(input.predicate, { nodes: 0 }, 1) }),
+		...(labels === undefined ? {} : { labels: labels as ActivationLabelMatch }),
 		priority: priority as number,
 		injection,
 	};
 }
 
 export function activationConfig(extra: Record<string, unknown>, defaultInjection: InjectionProfile = "full"): ActivationConfig {
-	if (extra.activation === undefined) return { priority: 0, injection: defaultInjection };
+	if (extra.activation === undefined) return { enabled: true, priority: 0, injection: defaultInjection };
 	try {
 		return validateActivationConfig(extra.activation, defaultInjection);
 	} catch {
-		return { priority: 0, injection: defaultInjection, invalid: true };
+		return { enabled: false, priority: 0, injection: defaultInjection, invalid: true };
 	}
 }
 
+/** Validates a replacement config while allowing the ergonomic standalone flag to override its enabled field. */
+export function validateActivationInput(
+	value: unknown,
+	enabled: boolean | undefined,
+	defaultInjection: InjectionProfile,
+): ActivationConfig | undefined {
+	if (value === undefined && enabled === undefined) return undefined;
+	const input = value === undefined ? {} : record(value, "activation");
+	return validateActivationConfig(enabled === undefined ? input : { ...input, enabled }, defaultInjection);
+}
+
+/** Applies the ergonomic standalone activation flag while retaining predicate/profile/priority settings. */
+export function activationConfigWithEnabled(
+	extra: Record<string, unknown>,
+	enabled: boolean,
+	defaultInjection: InjectionProfile,
+): ActivationConfig {
+	const current = extra.activation === undefined ? {} : record(extra.activation, "activation");
+	return validateActivationConfig({ ...current, enabled }, defaultInjection);
+}
+
 function contextValue(field: ActivationField, context: ActivationContext): string | string[] | undefined {
 	switch (field) {
 		case "project.root":
@@ -233,7 +271,24 @@ function evaluatePredicate(predicate: ActivationPredicate, context: ActivationCo
 		: { enabled: false, reason: `activation ${predicate.field} did not match ${predicate.operator}` };
 }
 
-export function evaluateActivation(config: ActivationConfig, context: ActivationContext): ActivationDecision {
+function normalizeLabel(value: string): string {
+	return value.trim().toLowerCase();
+}
+
+export function evaluateActivation(
+	config: ActivationConfig,
+	context: ActivationContext,
+	artifactLabels: readonly string[] = [],
+): ActivationDecision {
 	if (config.invalid) return { enabled: false, reason: "invalid activation configuration" };
+	if (!config.enabled) return { enabled: false, reason: "activation flag is disabled" };
+	if (config.labels !== undefined) {
+		const expected = [...new Set(artifactLabels.map(normalizeLabel).filter(Boolean))];
+		if (expected.length === 0) return { enabled: false, reason: "activation label matching has no artifact labels" };
+		const actual = new Set((context.taskLabels ?? []).map(normalizeLabel).filter(Boolean));
+		if (actual.size === 0) return { enabled: false, reason: "activation context field task.labels is unavailable" };
+		const matches = config.labels === "all" ? expected.every((label) => actual.has(label)) : expected.some((label) => actual.has(label));
+		if (!matches) return { enabled: false, reason: `activation artifact labels did not match ${config.labels}` };
+	}
 	return config.predicate === undefined ? { enabled: true, reason: "enabled" } : evaluatePredicate(config.predicate, context);
 }

package/src/cli/playbooks-command.ts

@@ -18,6 +18,12 @@ function parseStringArray(value: string): string[] {
 	return parsed as string[];
 }
 
+function parseBoolean(value: string): boolean {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	throw new Error("value must be true or false");
+}
+
 function parseObject(value: string): Record<string, unknown> {
 	const parsed = JSON.parse(value) as unknown;
 	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("value must be a JSON object");
@@ -52,6 +58,7 @@ const createCommand = buildCommand({
 			labelsJson?: string[];
 			extraJson?: Record<string, unknown>;
 			activationJson?: Record<string, unknown>;
+			activationEnabled?: boolean;
 			argumentsJson?: unknown[] | Record<string, unknown>;
 			projectRoot?: string;
 			projectsJson?: string[];
@@ -66,6 +73,7 @@ const createCommand = buildCommand({
 			labels: flags.labelsJson,
 			extra: flags.extraJson,
 			activation: flags.activationJson,
+			activation_enabled: flags.activationEnabled,
 			arguments: flags.argumentsJson,
 			project_root: flags.projectRoot,
 			projects: flags.projectsJson,
@@ -88,12 +96,19 @@ const createCommand = buildCommand({
 			labelsJson: { brief: "JSON string array of labels", kind: "parsed", parse: parseStringArray, placeholder: "json", optional: true },
 			extraJson: { brief: "JSON object of extra fields", kind: "parsed", parse: parseObject, placeholder: "json", optional: true },
 			activationJson: {
-				brief: "Typed activation config as JSON: {predicate?,priority?,injection?}",
+				brief: "Typed activation config as JSON: {enabled?,predicate?,labels?,priority?,injection?}",
 				kind: "parsed",
 				parse: parseObject,
 				placeholder: "json",
 				optional: true,
 			},
+			activationEnabled: {
+				brief: "Persisted manual activation flag (true|false)",
+				kind: "parsed",
+				parse: parseBoolean,
+				placeholder: "boolean",
+				optional: true,
+			},
 			argumentsJson: {
 				brief: "JSON array of declared argument definitions",
 				kind: "parsed",
@@ -422,6 +437,7 @@ const updateCommand = buildCommand({
 			trigger?: string;
 			stepsJson?: unknown[] | Record<string, unknown>;
 			activationJson?: Record<string, unknown>;
+			activationEnabled?: boolean;
 		},
 		id: string,
 	) {
@@ -431,9 +447,12 @@ const updateCommand = buildCommand({
 			flags.labelsJson === undefined &&
 			flags.trigger === undefined &&
 			flags.stepsJson === undefined &&
-			flags.activationJson === undefined
+			flags.activationJson === undefined &&
+			flags.activationEnabled === undefined
 		)
-			throw new Error("playbooks update requires --title, --body, --labels-json, --trigger, --steps-json, or --activation-json");
+			throw new Error(
+				"playbooks update requires --title, --body, --labels-json, --trigger, --steps-json, --activation-json, or --activation-enabled",
+			);
 		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("playbooks.update", {
 			id,
 			title: flags.title,
@@ -442,6 +461,7 @@ const updateCommand = buildCommand({
 			trigger: flags.trigger,
 			steps: flags.stepsJson,
 			activation: flags.activationJson,
+			activation_enabled: flags.activationEnabled,
 		});
 		render.call(this, artifact, artifactLabel(artifact));
 	},
@@ -465,6 +485,13 @@ const updateCommand = buildCommand({
 				placeholder: "json",
 				optional: true,
 			},
+			activationEnabled: {
+				brief: "Persisted manual activation flag (true|false)",
+				kind: "parsed",
+				parse: parseBoolean,
+				placeholder: "boolean",
+				optional: true,
+			},
 		},
 		positional: { kind: "tuple", parameters: [{ brief: "Playbook id", parse: String, placeholder: "id" }] },
 	},

package/src/cli/rules-command.ts

@@ -20,6 +20,12 @@ function parseStringArray(value: string): string[] {
 	return parsed as string[];
 }
 
+function parseBoolean(value: string): boolean {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	throw new Error("value must be true or false");
+}
+
 function parseObject(value: string): Record<string, unknown> {
 	const parsed = JSON.parse(value) as unknown;
 	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("value must be a JSON object");
@@ -42,6 +48,7 @@ const createCommand = buildCommand({
 			labelsJson?: string[];
 			extraJson?: Record<string, unknown>;
 			activationJson?: Record<string, unknown>;
+			activationEnabled?: boolean;
 			projectRoot?: string;
 		},
 	) {
@@ -54,6 +61,7 @@ const createCommand = buildCommand({
 			labels: flags.labelsJson,
 			extra: flags.extraJson,
 			activation: flags.activationJson,
+			activation_enabled: flags.activationEnabled,
 			project_root: flags.projectRoot,
 		});
 		render.call(this, artifact, `Created rule: ${artifactLabel(artifact)}`);
@@ -68,12 +76,19 @@ const createCommand = buildCommand({
 			labelsJson: { brief: "JSON string array of labels", kind: "parsed", parse: parseStringArray, placeholder: "json", optional: true },
 			extraJson: { brief: "JSON object of extra fields", kind: "parsed", parse: parseObject, placeholder: "json", optional: true },
 			activationJson: {
-				brief: "Typed activation config as JSON: {predicate?,priority?,injection?}",
+				brief: "Typed activation config as JSON: {enabled?,predicate?,labels?,priority?,injection?}",
 				kind: "parsed",
 				parse: parseObject,
 				placeholder: "json",
 				optional: true,
 			},
+			activationEnabled: {
+				brief: "Persisted manual activation flag (true|false)",
+				kind: "parsed",
+				parse: parseBoolean,
+				placeholder: "boolean",
+				optional: true,
+			},
 			projectRoot: { brief: "Project scope", kind: "parsed", parse: String, placeholder: "path", optional: true },
 		},
 	},
@@ -352,17 +367,30 @@ const injectableCommand = buildCommand({
 const updateCommand = buildCommand({
 	func: async function (
 		this: RulesContext,
-		flags: { title?: string; body?: string; labelsJson?: string[]; activationJson?: Record<string, unknown> },
+		flags: {
+			title?: string;
+			body?: string;
+			labelsJson?: string[];
+			activationJson?: Record<string, unknown>;
+			activationEnabled?: boolean;
+		},
 		id: string,
 	) {
-		if (flags.title === undefined && flags.body === undefined && flags.labelsJson === undefined && flags.activationJson === undefined)
-			throw new Error("rules update requires --title, --body, --labels-json, or --activation-json");
+		if (
+			flags.title === undefined &&
+			flags.body === undefined &&
+			flags.labelsJson === undefined &&
+			flags.activationJson === undefined &&
+			flags.activationEnabled === undefined
+		)
+			throw new Error("rules update requires --title, --body, --labels-json, --activation-json, or --activation-enabled");
 		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("rules.update", {
 			id,
 			title: flags.title,
 			body: flags.body,
 			labels: flags.labelsJson,
 			activation: flags.activationJson,
+			activation_enabled: flags.activationEnabled,
 		});
 		render.call(this, artifact, artifactLabel(artifact));
 	},
@@ -378,6 +406,13 @@ const updateCommand = buildCommand({
 				placeholder: "json",
 				optional: true,
 			},
+			activationEnabled: {
+				brief: "Persisted manual activation flag (true|false)",
+				kind: "parsed",
+				parse: parseBoolean,
+				placeholder: "boolean",
+				optional: true,
+			},
 		},
 		positional: { kind: "tuple", parameters: [{ brief: "Rule id", parse: String, placeholder: "id" }] },
 	},

package/src/handlers/activation.ts

@@ -26,7 +26,7 @@ export function registerActivationVehicleOperations(
 	});
 	define(
 		"audit",
-		"Audits every Rule and Playbook against lifecycle, project/scope-group applicability, run ownership, and typed activation predicates. Returns enabled/disabled decisions, exclusion reasons, priority, injection profile, scope counts, and estimated enabled tokens.",
+		"Audits every Rule and Playbook against lifecycle, project/scope-group applicability, run ownership, the persisted activation flag, artifact-label matching, and typed predicates. Returns enabled/disabled decisions, exclusion reasons, activation settings, priority, injection profile, scope counts, and estimated enabled tokens.",
 		"read",
 		{
 			project_root: stringProp,

package/src/handlers/playbooks.ts

@@ -105,7 +105,8 @@ export function registerPlaybooksVehicleOperations(registry: VehicleRegistry, de
 			subtype: stringProp,
 			labels: { type: "array" },
 			extra: { type: "object" },
-			activation: { type: "object", description: "Typed activation config: {predicate?,priority?,injection?}." },
+			activation: { type: "object", description: "Typed activation config: {enabled?,predicate?,labels?,priority?,injection?}." },
+			activation_enabled: { ...booleanProp, description: "Persisted manual activation flag; defaults true." },
 			template_id: stringProp,
 			project_root: stringProp,
 			projects: { type: "array" },
@@ -327,6 +328,7 @@ export function registerPlaybooksVehicleOperations(registry: VehicleRegistry, de
 			trigger: stringProp,
 			steps: { type: "array" },
 			activation: { type: "object", description: "Replacement typed activation config." },
+			activation_enabled: { ...booleanProp, description: "Persisted manual activation flag; retains other activation settings." },
 			actor: stringProp,
 			source: stringProp,
 			session_id: stringProp,

package/src/handlers/rules.ts

@@ -77,9 +77,13 @@ export function registerRulesVehicleOperations(
 			subtype: stringProp,
 			labels: { type: "array" } as unknown as { type: string },
 			extra: { type: "object" } as unknown as { type: string },
-			activation: { type: "object", description: "Typed activation config: {predicate?,priority?,injection?}." } as unknown as {
+			activation: {
+				type: "object",
+				description: "Typed activation config: {enabled?,predicate?,labels?,priority?,injection?}.",
+			} as unknown as {
 				type: string;
 			},
+			activation_enabled: { ...booleanProp, description: "Persisted manual activation flag; defaults true." },
 			template_id: stringProp,
 			project_root: stringProp,
 			projects: { type: "array" } as unknown as { type: string },
@@ -318,6 +322,7 @@ export function registerRulesVehicleOperations(
 			body: stringProp,
 			labels: { type: "array" } as unknown as { type: string },
 			activation: { type: "object", description: "Replacement typed activation config." } as unknown as { type: string },
+			activation_enabled: { ...booleanProp, description: "Persisted manual activation flag; retains other activation settings." },
 			project_root: stringProp,
 			actor: stringProp,
 			source: stringProp,

package/src/index.ts

@@ -9,6 +9,7 @@ export type { Artifact, ArtifactEdge } from "./artifact/artifact.ts";
 export {
 	type ActivationConfig,
 	type ActivationContext,
+	type ActivationLabelMatch,
 	type ActivationPredicate,
 	activationConfig,
 	type InjectionProfile,

package/src/modules/playbooks.ts

@@ -150,6 +150,7 @@ export function playbooksOperations({
 					labels: input.labels as string[] | undefined,
 					extra: input.extra as Record<string, unknown> | undefined,
 					activation: input.activation,
+					activationEnabled: optionalBoolean(input, "activation_enabled"),
 					templateId: optionalString(input, "template_id") ?? optionalString(input, "templateId"),
 					projectRoot: optionalString(input, "project_root"),
 					projectReferences: input.projects as string[] | undefined,
@@ -243,6 +244,7 @@ export function playbooksOperations({
 					trigger: optionalString(input, "trigger"),
 					steps: input.steps,
 					activation: input.activation,
+					activationEnabled: optionalBoolean(input, "activation_enabled"),
 				},
 				eventContext(input),
 			),

package/src/modules/rules.ts

@@ -121,6 +121,7 @@ export function rulesOperations(
 						labels: input.labels as string[] | undefined,
 						extra: input.extra as Record<string, unknown> | undefined,
 						activation: input.activation,
+						activationEnabled: optionalBoolean(input, "activation_enabled"),
 						templateId: optionalString(input, "template_id") ?? optionalString(input, "templateId"),
 						projectRoot: optionalString(input, "project_root"),
 						projectReferences: input.projects as string[] | undefined,
@@ -184,6 +185,7 @@ export function rulesOperations(
 						body: optionalString(input, "body"),
 						labels: input.labels as string[] | undefined,
 						activation: input.activation,
+						activationEnabled: optionalBoolean(input, "activation_enabled"),
 					},
 					eventContext(input),
 				),

package/src/playbook/playbook-service.ts

@@ -27,9 +27,10 @@ import { requireLocallyOwnedContent } from "../artifact/artifact.ts";
 import {
 	type ActivationContext,
 	activationConfig,
+	activationConfigWithEnabled,
 	evaluateActivation,
 	type InjectionProfile,
-	validateActivationConfig,
+	validateActivationInput,
 } from "../artifact/artifact-activation.ts";
 import type { ArtifactEventContext } from "../artifact/artifact-event.ts";
 import type { ArtifactScope, ArtifactScopeStore } from "../artifact/artifact-scope-store.ts";
@@ -234,6 +235,7 @@ export interface CreatePlaybookInput {
 	labels?: string[];
 	extra?: Record<string, unknown>;
 	activation?: unknown;
+	activationEnabled?: boolean;
 	templateId?: string;
 	projectRoot?: string;
 	/** Bounded exact registered project references (id/name/alias/root) -- fail-closed unlike projectRoot's auto-register-by-root legacy form. Takes precedence over projectRoot when both are given. */
@@ -255,6 +257,7 @@ export interface UpdatePlaybookInput extends UpdateContentInput {
 	trigger?: string;
 	steps?: unknown;
 	activation?: unknown;
+	activationEnabled?: boolean;
 }
 
 const PLAYBOOK_TRANSITIONS: TransitionTable<PlaybookTransition, string> = {
@@ -275,7 +278,7 @@ export function createPlaybook(
 	const projectRoot = input.projectRoot === undefined ? undefined : normalizeProjectRoot(input.projectRoot);
 	const declaredArguments = validatePlaybookArguments(input.arguments);
 	const declaredSteps = validatePlaybookSteps(input.steps);
-	const activation = input.activation === undefined ? undefined : validateActivationConfig(input.activation, "catalog");
+	const activation = validateActivationInput(input.activation, input.activationEnabled, "catalog");
 	const playbook = artifacts.create(
 		{
 			kind: "playbook",
@@ -315,7 +318,7 @@ export function listActivatedPlaybooks(
 	context: ActivationContext,
 ): Artifact[] {
 	return listPlaybooks(artifacts, scopes, filter).filter(
-		(playbook) => evaluateActivation(activationConfig(playbook.extra, "catalog"), context).enabled,
+		(playbook) => evaluateActivation(activationConfig(playbook.extra, "catalog"), context, playbook.labels).enabled,
 	);
 }
 
@@ -324,7 +327,7 @@ export function playbookActivationDecision(
 	context: ActivationContext,
 ): { enabled: boolean; reason: string; priority: number; injection: InjectionProfile } {
 	const config = activationConfig(playbook.extra, "catalog");
-	return { ...evaluateActivation(config, context), priority: config.priority, injection: config.injection };
+	return { ...evaluateActivation(config, context, playbook.labels), priority: config.priority, injection: config.injection };
 }
 
 export function assignPlaybookProject(
@@ -440,9 +443,10 @@ export function updatePlaybook(artifacts: ArtifactStore, id: string, input: Upda
 		input.labels === undefined &&
 		input.trigger === undefined &&
 		input.steps === undefined &&
-		input.activation === undefined
+		input.activation === undefined &&
+		input.activationEnabled === undefined
 	) {
-		throw new Error("update requires title, body, labels, trigger, steps, or activation");
+		throw new Error("update requires title, body, labels, trigger, steps, activation, or activationEnabled");
 	}
 	assertTitleBounds(input.title);
 	assertBodyBounds(input.body);
@@ -454,8 +458,12 @@ export function updatePlaybook(artifacts: ArtifactStore, id: string, input: Upda
 	const hasContentFields = input.title !== undefined || input.body !== undefined || input.labels !== undefined;
 	const updated = hasContentFields ? artifacts.updateContent(playbook.id, input, context) : playbook;
 	if (!updated) throw new Error(`playbook "${id}" not found`);
-	if (declaredSteps === undefined && input.trigger === undefined && input.activation === undefined) return updated;
-	const activation = input.activation === undefined ? undefined : validateActivationConfig(input.activation, "catalog");
+	if (declaredSteps === undefined && input.trigger === undefined && input.activation === undefined && input.activationEnabled === undefined)
+		return updated;
+	const activation =
+		input.activation === undefined && input.activationEnabled !== undefined
+			? activationConfigWithEnabled(updated.extra, input.activationEnabled, "catalog")
+			: validateActivationInput(input.activation, input.activationEnabled, "catalog");
 	const withExtra = artifacts.setExtra(
 		updated.id,
 		{

package/src/rules/rules-service.ts

@@ -10,9 +10,10 @@ import { requireLocallyOwnedContent } from "../artifact/artifact.ts";
 import {
 	type ActivationContext,
 	activationConfig,
+	activationConfigWithEnabled,
 	evaluateActivation,
 	type InjectionProfile,
-	validateActivationConfig,
+	validateActivationInput,
 } from "../artifact/artifact-activation.ts";
 import type { ArtifactEventContext } from "../artifact/artifact-event.ts";
 import type { ArtifactScope, ArtifactScopeStore } from "../artifact/artifact-scope-store.ts";
@@ -50,6 +51,7 @@ export interface CreateRuleInput {
 	labels?: string[];
 	extra?: Record<string, unknown>;
 	activation?: unknown;
+	activationEnabled?: boolean;
 	templateId?: string;
 	projectRoot?: string;
 	/** Bounded exact registered project references (id/name/alias/root) -- fail-closed unlike projectRoot's auto-register-by-root legacy form. Takes precedence over projectRoot when both are given. */
@@ -142,7 +144,7 @@ export function createRule(
 	registry?: ProjectRegistryStore,
 ): Artifact {
 	assertRuleTextWithinBounds(input.condition, input.action, input.body);
-	const activation = input.activation === undefined ? undefined : validateActivationConfig(input.activation, "full");
+	const activation = validateActivationInput(input.activation, input.activationEnabled, "full");
 	if (input.projectReferences !== undefined && input.projectReferences.length > 0 && registry === undefined) {
 		throw new Error("projectReferences requires a project registry");
 	}
@@ -308,7 +310,7 @@ export function listInjectableRules(
 	return artifacts.query({ kind: "rule", status: "active" }).filter((rule) => {
 		if (rule.subtype === "artifact-template") return false;
 		if (!passesRuleRunScope(rule, activeTaskId) || !scopes.appliesToProjectRoot(rule.id, projectRoot)) return false;
-		return evaluateActivation(activationConfig(rule.extra, "full"), { ...context, projectRoot }).enabled;
+		return evaluateActivation(activationConfig(rule.extra, "full"), { ...context, projectRoot }, rule.labels).enabled;
 	});
 }
 
@@ -317,7 +319,7 @@ export function ruleActivationDecision(
 	context: ActivationContext,
 ): { enabled: boolean; reason: string; priority: number; injection: InjectionProfile } {
 	const config = activationConfig(rule.extra, "full");
-	return { ...evaluateActivation(config, context), priority: config.priority, injection: config.injection };
+	return { ...evaluateActivation(config, context, rule.labels), priority: config.priority, injection: config.injection };
 }
 
 export function showRule(artifacts: ArtifactStore, id: string): Artifact {
@@ -340,12 +342,19 @@ export function transitionRule(artifacts: ArtifactStore, id: string, action: Rul
 
 export interface UpdateRuleInput extends UpdateContentInput {
 	activation?: unknown;
+	activationEnabled?: boolean;
 }
 
 /** A Rule's body update stays under the same combined condition+action+body ceiling as creation -- a permanent per-turn injection cost doesn't get looser just because it's an edit, not a create. */
 export function updateRule(artifacts: ArtifactStore, id: string, input: UpdateRuleInput, context?: ArtifactEventContext): Artifact {
-	if (input.title === undefined && input.body === undefined && input.labels === undefined && input.activation === undefined) {
-		throw new Error("update requires title, body, labels, or activation");
+	if (
+		input.title === undefined &&
+		input.body === undefined &&
+		input.labels === undefined &&
+		input.activation === undefined &&
+		input.activationEnabled === undefined
+	) {
+		throw new Error("update requires title, body, labels, activation, or activationEnabled");
 	}
 	assertTitleBounds(input.title);
 	assertLabelsBounds(input.labels);
@@ -358,8 +367,11 @@ export function updateRule(artifacts: ArtifactStore, id: string, input: UpdateRu
 	const hasContent = input.title !== undefined || input.body !== undefined || input.labels !== undefined;
 	const updated = hasContent ? artifacts.updateContent(id, input, context) : rule;
 	if (!updated) throw new Error(`rule "${id}" not found`);
-	if (input.activation === undefined) return updated;
-	const activation = validateActivationConfig(input.activation, "full");
+	if (input.activation === undefined && input.activationEnabled === undefined) return updated;
+	const activation =
+		input.activation === undefined
+			? activationConfigWithEnabled(updated.extra, input.activationEnabled!, "full")
+			: validateActivationInput(input.activation, input.activationEnabled, "full")!;
 	const withActivation = artifacts.setExtra(updated.id, { ...updated.extra, activation }, context);
 	if (!withActivation) throw new Error(`rule "${id}" not found`);
 	return withActivation;