@namzu/sdk 38.2.1 → 39.0.0

package/dist/manager/resident/learning.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { type HarnessProtectionPlan } from '../../eval/harness-protection.js';
 import { type HarnessVerificationBatch } from '../../eval/harness-verification.js';
 export declare const residentLearningEvidenceSchema: z.ZodObject<{
     key: z.ZodString;
@@ -15,25 +16,101 @@ export declare const residentLearningEvidenceSchema: z.ZodObject<{
 }>;
 /** @experimental Host provenance for a correction, evaluated activation or rollback. */
 export type ResidentLearningEvidence = Readonly<z.infer<typeof residentLearningEvidenceSchema>>;
+declare const sourceSchema: z.ZodObject<{
+    key: z.ZodString;
+    revision: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    revision: string;
+}, {
+    key: string;
+    revision: string;
+}>;
+/** @experimental Host-owned source identity and revision; neither is a model assertion. */
+export type ResidentLearningSource = Readonly<z.infer<typeof sourceSchema>>;
 declare const candidateSchema: z.ZodObject<{
     name: z.ZodString;
+    /** Omitted means ordinary task guidance; exploration policies require explicit projection. */
+    purpose: z.ZodOptional<z.ZodEnum<["task", "exploration"]>>;
     description: z.ZodString;
     body: z.ZodString;
+    /** Optional dependencies whose revisions must still match before projection. */
+    sources: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        revision: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        revision: string;
+    }, {
+        key: string;
+        revision: string;
+    }>, "many">, {
+        key: string;
+        revision: string;
+    }[], {
+        key: string;
+        revision: string;
+    }[]>, {
+        key: string;
+        revision: string;
+    }[], {
+        key: string;
+        revision: string;
+    }[]>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     description: string;
     body: string;
+    sources?: {
+        key: string;
+        revision: string;
+    }[] | undefined;
+    purpose?: "task" | "exploration" | undefined;
 }, {
     name: string;
     description: string;
     body: string;
+    sources?: {
+        key: string;
+        revision: string;
+    }[] | undefined;
+    purpose?: "task" | "exploration" | undefined;
 }>;
 /** @experimental Instructional guidance only; never executable assets or tool permissions. */
-export type ResidentSkillCandidate = Readonly<z.infer<typeof candidateSchema>>;
+export type ResidentSkillCandidate = Readonly<Omit<z.infer<typeof candidateSchema>, 'sources'>> & {
+    readonly sources?: readonly ResidentLearningSource[];
+};
+/** Internal canonical snapshot, including immutable source bindings. */
+export declare function normalizeResidentSkill(input: ResidentSkillCandidate): ResidentSkillCandidate;
 declare const learnedSkillSchema: z.ZodObject<{
     name: z.ZodString;
+    /** Omitted means ordinary task guidance; exploration policies require explicit projection. */
+    purpose: z.ZodOptional<z.ZodEnum<["task", "exploration"]>>;
     description: z.ZodString;
     body: z.ZodString;
+    /** Optional dependencies whose revisions must still match before projection. */
+    sources: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        revision: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        revision: string;
+    }, {
+        key: string;
+        revision: string;
+    }>, "many">, {
+        key: string;
+        revision: string;
+    }[], {
+        key: string;
+        revision: string;
+    }[]>, {
+        key: string;
+        revision: string;
+    }[], {
+        key: string;
+        revision: string;
+    }[]>>;
 } & {
     hash: z.ZodString;
     evidence: z.ZodObject<{
@@ -55,18 +132,42 @@ declare const learnedSkillSchema: z.ZodObject<{
         evidenceDigest: z.ZodString;
         verificationTasks: z.ZodNumber;
         confirmationTasks: z.ZodNumber;
+        /** Absent only on historical activations made before protection was required. */
+        protection: z.ZodOptional<z.ZodObject<{
+            verificationTasks: z.ZodNumber;
+            confirmationTasks: z.ZodNumber;
+            planDigest: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            verificationTasks: number;
+            confirmationTasks: number;
+            planDigest: string;
+        }, {
+            verificationTasks: number;
+            confirmationTasks: number;
+            planDigest: string;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         baselineHash: string;
         candidateHash: string;
         evidenceDigest: string;
         verificationTasks: number;
         confirmationTasks: number;
+        protection?: {
+            verificationTasks: number;
+            confirmationTasks: number;
+            planDigest: string;
+        } | undefined;
     }, {
         baselineHash: string;
         candidateHash: string;
         evidenceDigest: string;
         verificationTasks: number;
         confirmationTasks: number;
+        protection?: {
+            verificationTasks: number;
+            confirmationTasks: number;
+            planDigest: string;
+        } | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -77,6 +178,11 @@ declare const learnedSkillSchema: z.ZodObject<{
         evidenceDigest: string;
         verificationTasks: number;
         confirmationTasks: number;
+        protection?: {
+            verificationTasks: number;
+            confirmationTasks: number;
+            planDigest: string;
+        } | undefined;
     };
     body: string;
     hash: string;
@@ -85,6 +191,11 @@ declare const learnedSkillSchema: z.ZodObject<{
         key: string;
         reason: string;
     };
+    sources?: {
+        key: string;
+        revision: string;
+    }[] | undefined;
+    purpose?: "task" | "exploration" | undefined;
 }, {
     name: string;
     description: string;
@@ -94,6 +205,11 @@ declare const learnedSkillSchema: z.ZodObject<{
         evidenceDigest: string;
         verificationTasks: number;
         confirmationTasks: number;
+        protection?: {
+            verificationTasks: number;
+            confirmationTasks: number;
+            planDigest: string;
+        } | undefined;
     };
     body: string;
     hash: string;
@@ -102,9 +218,16 @@ declare const learnedSkillSchema: z.ZodObject<{
         key: string;
         reason: string;
     };
+    sources?: {
+        key: string;
+        revision: string;
+    }[] | undefined;
+    purpose?: "task" | "exploration" | undefined;
 }>;
 /** @experimental Immutable evaluated content and evidence identity. */
-export type ResidentLearnedSkill = Readonly<z.infer<typeof learnedSkillSchema>>;
+export type ResidentLearnedSkill = Readonly<Omit<z.infer<typeof learnedSkillSchema>, 'sources'>> & {
+    readonly sources?: readonly ResidentLearningSource[];
+};
 export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
     revision: z.ZodNumber;
     identity: z.ZodOptional<z.ZodObject<{
@@ -172,8 +295,33 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
     }>, "many">;
     skills: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
+        /** Omitted means ordinary task guidance; exploration policies require explicit projection. */
+        purpose: z.ZodOptional<z.ZodEnum<["task", "exploration"]>>;
         description: z.ZodString;
         body: z.ZodString;
+        /** Optional dependencies whose revisions must still match before projection. */
+        sources: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            revision: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            key: string;
+            revision: string;
+        }, {
+            key: string;
+            revision: string;
+        }>, "many">, {
+            key: string;
+            revision: string;
+        }[], {
+            key: string;
+            revision: string;
+        }[]>, {
+            key: string;
+            revision: string;
+        }[], {
+            key: string;
+            revision: string;
+        }[]>>;
     } & {
         hash: z.ZodString;
         evidence: z.ZodObject<{
@@ -195,18 +343,42 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             evidenceDigest: z.ZodString;
             verificationTasks: z.ZodNumber;
             confirmationTasks: z.ZodNumber;
+            /** Absent only on historical activations made before protection was required. */
+            protection: z.ZodOptional<z.ZodObject<{
+                verificationTasks: z.ZodNumber;
+                confirmationTasks: z.ZodNumber;
+                planDigest: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                verificationTasks: number;
+                confirmationTasks: number;
+                planDigest: string;
+            }, {
+                verificationTasks: number;
+                confirmationTasks: number;
+                planDigest: string;
+            }>>;
         }, "strip", z.ZodTypeAny, {
             baselineHash: string;
             candidateHash: string;
             evidenceDigest: string;
             verificationTasks: number;
             confirmationTasks: number;
+            protection?: {
+                verificationTasks: number;
+                confirmationTasks: number;
+                planDigest: string;
+            } | undefined;
         }, {
             baselineHash: string;
             candidateHash: string;
             evidenceDigest: string;
             verificationTasks: number;
             confirmationTasks: number;
+            protection?: {
+                verificationTasks: number;
+                confirmationTasks: number;
+                planDigest: string;
+            } | undefined;
         }>;
     }, "strip", z.ZodTypeAny, {
         name: string;
@@ -217,6 +389,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             evidenceDigest: string;
             verificationTasks: number;
             confirmationTasks: number;
+            protection?: {
+                verificationTasks: number;
+                confirmationTasks: number;
+                planDigest: string;
+            } | undefined;
         };
         body: string;
         hash: string;
@@ -225,6 +402,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             key: string;
             reason: string;
         };
+        sources?: {
+            key: string;
+            revision: string;
+        }[] | undefined;
+        purpose?: "task" | "exploration" | undefined;
     }, {
         name: string;
         description: string;
@@ -234,6 +416,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             evidenceDigest: string;
             verificationTasks: number;
             confirmationTasks: number;
+            protection?: {
+                verificationTasks: number;
+                confirmationTasks: number;
+                planDigest: string;
+            } | undefined;
         };
         body: string;
         hash: string;
@@ -242,6 +429,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             key: string;
             reason: string;
         };
+        sources?: {
+            key: string;
+            revision: string;
+        }[] | undefined;
+        purpose?: "task" | "exploration" | undefined;
     }>, "many">;
     lastChange: z.ZodObject<{
         key: z.ZodString;
@@ -266,6 +458,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             evidenceDigest: string;
             verificationTasks: number;
             confirmationTasks: number;
+            protection?: {
+                verificationTasks: number;
+                confirmationTasks: number;
+                planDigest: string;
+            } | undefined;
         };
         body: string;
         hash: string;
@@ -274,6 +471,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             key: string;
             reason: string;
         };
+        sources?: {
+            key: string;
+            revision: string;
+        }[] | undefined;
+        purpose?: "task" | "exploration" | undefined;
     }[];
     revision: number;
     preferences: {
@@ -308,6 +510,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             evidenceDigest: string;
             verificationTasks: number;
             confirmationTasks: number;
+            protection?: {
+                verificationTasks: number;
+                confirmationTasks: number;
+                planDigest: string;
+            } | undefined;
         };
         body: string;
         hash: string;
@@ -316,6 +523,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             key: string;
             reason: string;
         };
+        sources?: {
+            key: string;
+            revision: string;
+        }[] | undefined;
+        purpose?: "task" | "exploration" | undefined;
     }[];
     revision: number;
     preferences: {
@@ -350,6 +562,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             evidenceDigest: string;
             verificationTasks: number;
             confirmationTasks: number;
+            protection?: {
+                verificationTasks: number;
+                confirmationTasks: number;
+                planDigest: string;
+            } | undefined;
         };
         body: string;
         hash: string;
@@ -358,6 +575,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             key: string;
             reason: string;
         };
+        sources?: {
+            key: string;
+            revision: string;
+        }[] | undefined;
+        purpose?: "task" | "exploration" | undefined;
     }[];
     revision: number;
     preferences: {
@@ -392,6 +614,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             evidenceDigest: string;
             verificationTasks: number;
             confirmationTasks: number;
+            protection?: {
+                verificationTasks: number;
+                confirmationTasks: number;
+                planDigest: string;
+            } | undefined;
         };
         body: string;
         hash: string;
@@ -400,6 +627,11 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
             key: string;
             reason: string;
         };
+        sources?: {
+            key: string;
+            revision: string;
+        }[] | undefined;
+        purpose?: "task" | "exploration" | undefined;
     }[];
     revision: number;
     preferences: {
@@ -452,6 +684,8 @@ export interface ResidentProfileUpdate {
 }
 /** @experimental Recorded paired runs; hosts own execution, scoring and independent attribution. */
 export interface ResidentSkillEvaluation {
+    /** Host-owned task selection fixed before generating the candidate. */
+    readonly protection: HarnessProtectionPlan;
     readonly verification: HarnessVerificationBatch;
     readonly confirmation?: HarnessVerificationBatch;
 }
@@ -459,7 +693,7 @@ export interface ResidentSkillEvaluation {
 export declare function freezeResidentLearning(input: ResidentLearningState): ResidentLearningState;
 /** Internal pure profile transition; storage owns exact agenda CAS and idle admission. */
 export declare function reviseResidentProfile(current: ResidentLearningState | undefined, input: ResidentProfileUpdate): ResidentLearningState;
-/** @experimental Bind evaluation to the exact normalized name, description and body. */
+/** @experimental Bind evaluation to normalized content and any declared source dependencies. */
 export declare function hashResidentSkill(input: ResidentSkillCandidate): string;
 /** Internal pure activation; reuse the kernel's conservative two-round verification gate. */
 export declare function promoteResidentSkill(current: ResidentLearningState | undefined, input: ResidentSkillCandidate, evaluation: ResidentSkillEvaluation, inputEvidence: ResidentLearningEvidence): ResidentLearningState;
@@ -469,6 +703,10 @@ export declare function restoreResidentSkill(current: ResidentLearningState | un
 export interface ResidentLearningProjectionOptions {
     readonly maxChars: number;
     readonly skillNames: readonly string[];
+    /** Defaults to task guidance. Exploration policies never enter ordinary task context. */
+    readonly purpose?: 'task' | 'exploration';
+    /** Fresh host observations for this projection; absent/mismatched dependencies withhold guidance. */
+    readonly sources?: readonly ResidentLearningSource[];
 }
 /** @experimental Omitted entries are counted; no partial skill instruction is emitted. */
 export interface ResidentLearningProjection {
@@ -476,6 +714,11 @@ export interface ResidentLearningProjection {
     readonly revision: number | null;
     readonly includedSkills: readonly string[];
     readonly omitted: number;
+    readonly withheldSkills: readonly {
+        readonly name: string;
+        readonly reason: 'changed-source' | 'unverified-source' | 'different-purpose';
+        readonly sourceKeys: readonly string[];
+    }[];
 }
 /** @experimental Bounded context data; never registers tools, loads files or executes a skill. */
 export declare function projectResidentLearning(current: ResidentLearningState | undefined, options: ResidentLearningProjectionOptions): ResidentLearningProjection;

package/dist/manager/resident/learning.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"learning.d.ts","sourceRoot":"","sources":["../../../src/manager/resident/learning.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EACN,KAAK,wBAAwB,EAE7B,MAAM,oCAAoC,CAAA;AAK3C,eAAO,MAAM,8BAA8B;;;;;;;;;;;;EAIzC,CAAA;AAEF,wFAAwF;AACxF,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC,CAAA;AAE/F,QAAA,MAAM,eAAe;;;;;;;;;;;;EAInB,CAAA;AAEF,8FAA8F;AAC9F,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC,CAAA;AAE9E,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUtB,CAAA;AAEF,uEAAuE;AACvE,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAA;AAE/E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmChC,CAAA;AAEH,mGAAmG;AACnG,MAAM,WAAW,qBAAqB;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAA;KAAE,CAAA;IAC1F,QAAQ,CAAC,WAAW,EAAE,SAAS;QAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;QACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;QACtB,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAA;KAC3C,EAAE,CAAA;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAA;IAChD,QAAQ,CAAC,UAAU,EAAE,wBAAwB,CAAA;CAC7C;AAED,qFAAqF;AACrF,MAAM,WAAW,qBAAqB;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS;QAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;QACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;QACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAClC,EAAE,CAAA;IACH,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAA;CAC3C;AAED,oGAAoG;AACpG,MAAM,WAAW,uBAAuB;IACvC,QAAQ,CAAC,YAAY,EAAE,wBAAwB,CAAA;IAC/C,QAAQ,CAAC,YAAY,CAAC,EAAE,wBAAwB,CAAA;CAChD;AAED,wEAAwE;AACxE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,qBAAqB,GAAG,qBAAqB,CA0B1F;AAgCD,0FAA0F;AAC1F,wBAAgB,qBAAqB,CACpC,OAAO,EAAE,qBAAqB,GAAG,SAAS,EAC1C,KAAK,EAAE,qBAAqB,GAC1B,qBAAqB,CAyCvB;AAED,wFAAwF;AACxF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,MAAM,CAKvE;AAED,6FAA6F;AAC7F,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,qBAAqB,GAAG,SAAS,EAC1C,KAAK,EAAE,sBAAsB,EAC7B,UAAU,EAAE,uBAAuB,EACnC,aAAa,EAAE,wBAAwB,GACrC,qBAAqB,CA4CvB;AAED,gGAAgG;AAChG,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,qBAAqB,GAAG,SAAS,EAC1C,UAAU,EAAE,qBAAqB,GAAG,SAAS,EAC7C,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,wBAAwB,GACrC,qBAAqB,CAYvB;AAED,sGAAsG;AACtG,MAAM,WAAW,iCAAiC;IACjD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC;AAED,0FAA0F;AAC1F,MAAM,WAAW,0BAA0B;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAA;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACxB;AAED,kGAAkG;AAClG,wBAAgB,uBAAuB,CACtC,OAAO,EAAE,qBAAqB,GAAG,SAAS,EAC1C,OAAO,EAAE,iCAAiC,GACxC,0BAA0B,CAsD5B"}
+{"version":3,"file":"learning.d.ts","sourceRoot":"","sources":["../../../src/manager/resident/learning.ts"],"names":[],"mappings":"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"}

package/dist/manager/resident/learning.js

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import { z } from 'zod';
+import { normalizeHarnessProtection, } from '../../eval/harness-protection.js';
 import { reviewHarnessCandidate, } from '../../eval/harness-verification.js';
 const label = z.string().trim().min(1).max(256);
 const name = z.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/);
@@ -9,11 +10,35 @@ export const residentLearningEvidenceSchema = z.object({
     source: label,
     reason: z.string().trim().min(1).max(1_000),
 });
+const sourceSchema = z.object({ key: label, revision: label });
+const sourcesSchema = z
+    .array(sourceSchema)
+    .min(1)
+    .max(8)
+    .superRefine((sources, context) => {
+    if (new Set(sources.map((source) => source.key)).size !== sources.length)
+        context.addIssue({ code: z.ZodIssueCode.custom, message: 'Duplicate learning source keys.' });
+})
+    .transform((sources) => sources.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0)));
 const candidateSchema = z.object({
     name,
+    /** Omitted means ordinary task guidance; exploration policies require explicit projection. */
+    purpose: z.enum(['task', 'exploration']).optional(),
     description: z.string().trim().min(1).max(1_000),
     body: z.string().trim().min(1).max(4_000),
+    /** Optional dependencies whose revisions must still match before projection. */
+    sources: sourcesSchema.optional(),
 });
+/** Internal canonical snapshot, including immutable source bindings. */
+export function normalizeResidentSkill(input) {
+    const candidate = candidateSchema.parse(input);
+    return Object.freeze({
+        ...candidate,
+        ...(candidate.sources
+            ? { sources: Object.freeze(candidate.sources.map((source) => Object.freeze(source))) }
+            : {}),
+    });
+}
 const learnedSkillSchema = candidateSchema.extend({
     hash: digest,
     evidence: residentLearningEvidenceSchema,
@@ -23,6 +48,14 @@ const learnedSkillSchema = candidateSchema.extend({
         evidenceDigest: digest,
         verificationTasks: z.number().int().min(5).max(64),
         confirmationTasks: z.number().int().min(5).max(64),
+        /** Absent only on historical activations made before protection was required. */
+        protection: z
+            .object({
+            verificationTasks: z.number().int().min(1).max(63),
+            confirmationTasks: z.number().int().min(1).max(63),
+            planDigest: digest,
+        })
+            .optional(),
     }),
 });
 export const residentLearningSchema = z
@@ -70,8 +103,16 @@ export function freezeResidentLearning(input) {
         preferences: Object.freeze(state.preferences.map((p) => Object.freeze({ ...p, evidence: Object.freeze(p.evidence) }))),
         skills: Object.freeze(state.skills.map((skill) => Object.freeze({
             ...skill,
+            ...(skill.sources
+                ? { sources: Object.freeze(skill.sources.map((source) => Object.freeze(source))) }
+                : {}),
             evidence: Object.freeze(skill.evidence),
-            verification: Object.freeze(skill.verification),
+            verification: Object.freeze({
+                ...skill.verification,
+                ...(skill.verification.protection
+                    ? { protection: Object.freeze(skill.verification.protection) }
+                    : {}),
+            }),
         }))),
         lastChange: Object.freeze(state.lastChange),
     });
@@ -139,18 +180,28 @@ export function reviseResidentProfile(current, input) {
         ...(checked.identity !== undefined ? { identity: { text: checked.identity, evidence } } : {}),
     });
 }
-/** @experimental Bind evaluation to the exact normalized name, description and body. */
+/** @experimental Bind evaluation to normalized content and any declared source dependencies. */
 export function hashResidentSkill(input) {
     const candidate = candidateSchema.parse(input);
     return createHash('sha256')
-        .update(JSON.stringify([candidate.name, candidate.description, candidate.body]))
+        .update(JSON.stringify([
+        candidate.name,
+        candidate.description,
+        candidate.body,
+        ...(candidate.sources ? [candidate.sources] : []),
+        ...(candidate.purpose === 'exploration' ? [{ purpose: candidate.purpose }] : []),
+    ]))
         .digest('hex');
 }
 /** Internal pure activation; reuse the kernel's conservative two-round verification gate. */
 export function promoteResidentSkill(current, input, evaluation, inputEvidence) {
+    const protection = normalizeHarnessProtection(evaluation.protection);
     const candidate = candidateSchema.parse(input);
     const hash = hashResidentSkill(candidate);
-    const baselineHash = current?.skills.find((s) => s.name === candidate.name)?.hash ?? 'none';
+    const baseline = current?.skills.find((s) => s.name === candidate.name);
+    if (baseline && (baseline.purpose ?? 'task') !== (candidate.purpose ?? 'task'))
+        throw new Error('A skill cannot change learning purpose; use a distinct skill name.');
+    const baselineHash = baseline?.hash ?? 'none';
     const evidence = evidenceFor(current, inputEvidence);
     for (const batch of [evaluation.verification, evaluation.confirmation]) {
         if (!batch)
@@ -168,7 +219,7 @@ export function promoteResidentSkill(current, input, evaluation, inputEvidence)
                 throw new Error('Inconsistent recorded skill evaluation outcome.');
         }
     }
-    const review = reviewHarnessCandidate(evaluation.verification, evaluation.confirmation);
+    const review = reviewHarnessCandidate(evaluation.verification, evaluation.confirmation, protection);
     if (review.decision !== 'accept')
         throw new Error(`Resident skill promotion ${review.decision}: ${review.reason}`);
     const skill = {
@@ -178,9 +229,16 @@ export function promoteResidentSkill(current, input, evaluation, inputEvidence)
         verification: {
             baselineHash,
             candidateHash: hash,
-            evidenceDigest: createHash('sha256').update(JSON.stringify(evaluation)).digest('hex'),
+            evidenceDigest: createHash('sha256')
+                .update(JSON.stringify({ ...evaluation, protection }))
+                .digest('hex'),
             verificationTasks: review.verification.tasks.length,
             confirmationTasks: review.confirmation?.tasks.length ?? 0,
+            protection: {
+                verificationTasks: protection.verification.length,
+                confirmationTasks: protection.confirmation.length,
+                planDigest: createHash('sha256').update(JSON.stringify(protection)).digest('hex'),
+            },
         },
     };
     const next = base(current, evidence);
@@ -208,18 +266,28 @@ export function projectResidentLearning(current, options) {
     if (!Number.isSafeInteger(options.maxChars) || options.maxChars < 0 || options.maxChars > 64_000)
         throw new TypeError('Resident learning context requires maxChars between 0 and 64000.');
     const selected = z.array(name).max(16).parse(options.skillNames);
+    const purpose = z.enum(['task', 'exploration']).parse(options.purpose ?? 'task');
     if (new Set(selected).size !== selected.length)
         throw new Error('Duplicate selected skill names.');
+    const sources = z
+        .array(sourceSchema)
+        .max(128)
+        .parse(options.sources ?? []);
+    if (new Set(sources.map((source) => source.key)).size !== sources.length)
+        throw new Error('Duplicate observed learning source keys.');
+    const observed = new Map(sources.map((source) => [source.key, source.revision]));
     if (!current)
         return Object.freeze({
             text: '',
             revision: null,
             includedSkills: Object.freeze([]),
             omitted: selected.length,
+            withheldSkills: Object.freeze([]),
         });
     const state = freezeResidentLearning(current);
     const pieces = [];
     const includedSkills = [];
+    const withheldSkills = [];
     let omitted = 0;
     let length = 0;
     const add = (value) => {
@@ -243,6 +311,27 @@ export function projectResidentLearning(current, options) {
             omitted++;
             continue;
         }
+        if ((skill.purpose ?? 'task') !== purpose) {
+            omitted++;
+            withheldSkills.push(Object.freeze({
+                name: skill.name,
+                reason: 'different-purpose',
+                sourceKeys: Object.freeze([]),
+            }));
+            continue;
+        }
+        const mismatched = skill.sources?.filter((source) => observed.get(source.key) !== source.revision) ?? [];
+        if (mismatched.length) {
+            omitted++;
+            withheldSkills.push(Object.freeze({
+                name: skill.name,
+                reason: mismatched.some((source) => observed.has(source.key))
+                    ? 'changed-source'
+                    : 'unverified-source',
+                sourceKeys: Object.freeze(mismatched.map((source) => source.key)),
+            }));
+            continue;
+        }
         if (add({
             kind: 'evaluated-guidance',
             name: skill.name,
@@ -258,6 +347,7 @@ export function projectResidentLearning(current, options) {
         revision: state.revision,
         includedSkills: Object.freeze(includedSkills),
         omitted,
+        withheldSkills: Object.freeze(withheldSkills),
     });
 }
 //# sourceMappingURL=learning.js.map