@namzu/sdk 55.0.0 → 56.0.0

package/dist/learning/leak-tripwire.js

@@ -0,0 +1,208 @@
+import { randomBytes } from 'node:crypto';
+/** @experimental Thrown for a leak. It is a leak, not a false positive: do not retry past it. */
+export class LearningLeakError extends Error {
+    findings;
+    constructor(findings) {
+        super(describeLeak(findings));
+        this.name = 'LearningLeakError';
+        this.findings = findings;
+    }
+}
+const MIN_PROTECTED_LENGTH = 12;
+const MAX_SCAN_CHARS = 1_000_000;
+const DEFAULT_MARKERS = [
+    ['grader-verdict', /\b(?:grader|judge|evaluator|scorer)[\s_-]*verdicts?\b/i],
+    ['answer-key', /\b(?:answer[\s_-]*key|expected[\s_-]*answers?|reference[\s_-]*answers?)\b/i],
+    [
+        'protection-fixture',
+        /\bprotection[\s_-]*(?:task|fixture)[\s_-]*(?:contents?|prompts?|answers?)\b/i,
+    ],
+    ['hidden-rubric', /\b(?:hidden|private|held[\s_-]*out)[\s_-]*(?:rubric|test[\s_-]*cases?)\b/i],
+];
+const DEFAULT_SECRETS = [
+    ['private-key', /-----BEGIN [A-Z ]*PRIVATE KEY-----/],
+    ['api-key', /\bsk-[A-Za-z0-9_-]{20,}/],
+    ['cloud-key', /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/],
+    ['token', /\b(?:gh[pousr]_[A-Za-z0-9]{30,}|xox[abprs]-[A-Za-z0-9-]{10,})/],
+    ['bearer', /\bBearer\s+[A-Za-z0-9._~+/-]{24,}=*/],
+];
+/** @experimental A fresh canary to plant in evaluator data. It matches nothing else. */
+export function createLearningCanary() {
+    return `namzu-canary-${randomBytes(12).toString('hex')}`;
+}
+/** Fold case, zero-width characters and whitespace runs so spacing tricks do not hide a match. */
+function fold(text) {
+    return text.replace(/[​-‏⁠]/g, '').replace(/\s+/g, ' ').toLowerCase();
+}
+function globToRegExp(glob) {
+    let out = '';
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === '*') {
+            if (glob[i + 1] === '*') {
+                i++;
+                if (glob[i + 1] === '/') {
+                    i++;
+                    out += '(?:.*/)?';
+                }
+                else
+                    out += '.*';
+            }
+            else
+                out += '[^/]*';
+        }
+        else if (c === '?')
+            out += '[^/]';
+        else
+            out += c.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    }
+    return new RegExp(`^${out}$`);
+}
+function normalizePath(path) {
+    return path
+        .replace(/\\/g, '/')
+        .replace(/^(?:\.\/)+/, '')
+        .replace(/\/{2,}/g, '/');
+}
+/** Tokens of a text that look like locations, so a path glob can be tried on them. */
+function pathTokens(text) {
+    return text
+        .split(/[\s"'`<>()[\]{},;|=]+/)
+        .map((token) => normalizePath(token.replace(/[:.]+$/, '')))
+        .filter((token) => token.length > 0 && token.length < 512);
+}
+/** Plain-text forms, matched against the folded (lowercased) text. Hex is case-insensitive that way. */
+function plainForms(canary) {
+    return [fold(canary), Buffer.from(canary, 'utf8').toString('hex')];
+}
+/**
+ * Base64 forms of the canary at each of the three alignments it can have inside
+ * a larger encoded blob, in standard and url-safe alphabets. The characters
+ * that depend on the bytes before or after the canary are dropped, so what is
+ * left is identical wherever the canary sits. Matched case-sensitively.
+ */
+function base64Forms(canary) {
+    const forms = new Set();
+    const body = Buffer.from(canary, 'utf8');
+    for (let lead = 0; lead < 3; lead++) {
+        const encoded = Buffer.concat([Buffer.alloc(lead, 0x78), body]).toString('base64');
+        const unpadded = encoded.replace(/=+$/, '');
+        const trailing = (lead + body.length) % 3 === 0 ? 0 : 1;
+        const stable = unpadded.slice(lead === 0 ? 0 : lead + 1, unpadded.length - trailing);
+        if (stable.length < 8)
+            continue;
+        forms.add(stable);
+        forms.add(stable.replace(/\+/g, '-').replace(/\//g, '_'));
+    }
+    return [...forms];
+}
+/** Text with whitespace and zero-width characters removed, so wrapped base64 still matches. */
+function compact(text) {
+    return text.replace(/[\u200b-\u200f\u2060\ufeff]/g, '').replace(/\s+/g, '');
+}
+function stripZeroWidth(text) {
+    return text.replace(/[\u200b-\u200f\u2060\ufeff]/g, '');
+}
+function compile(guard) {
+    const markers = [
+        ...DEFAULT_MARKERS.map(([n, r]) => [`default:${n}`, r]),
+    ];
+    for (const [i, marker] of (guard.markers ?? []).entries()) {
+        if (typeof marker !== 'string' && marker.global)
+            throw new Error('A leak marker must not be a global RegExp.');
+        const escaped = typeof marker === 'string'
+            ? new RegExp(fold(marker).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+            : marker;
+        markers.push([`marker[${i}]`, escaped]);
+    }
+    return {
+        paths: (guard.paths ?? []).map((g, i) => [`path[${i}]`, globToRegExp(normalizePath(g))]),
+        canaries: (guard.canaries ?? []).map((c, i) => {
+            if (fold(c).length < 8)
+                throw new Error('A leak canary must be at least 8 characters.');
+            return [`canary[${i}]`, plainForms(c), base64Forms(c)];
+        }),
+        markers,
+        protectedContents: (guard.protectedContents ?? []).flatMap((c, i) => {
+            const folded = fold(c).trim();
+            if (folded.length < MIN_PROTECTED_LENGTH)
+                throw new Error(`Protected content must be at least ${MIN_PROTECTED_LENGTH} characters; shorter text matches innocently.`);
+            return [[`protected-content[${i}]`, folded]];
+        }),
+        secrets: (guard.secrets ?? []).flatMap((s, i) => {
+            if (s.length < 8)
+                throw new Error('A literal secret to guard must be at least 8 characters.');
+            return [[`secret[${i}]`, s]];
+        }),
+    };
+}
+/**
+ * @experimental Inspect each subject against the guard (the built-in markers
+ * and secret shapes always apply). Returns every finding; empty means nothing
+ * was seen, which is not a proof that nothing leaked.
+ */
+export function scanForLearningLeak(guard, subjects) {
+    const compiled = compile(guard ?? {});
+    const findings = [];
+    const seen = new Set();
+    const add = (kind, subject, rule) => {
+        const key = `${kind}|${subject}|${rule}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        findings.push({ kind, subject, rule });
+    };
+    for (const item of subjects) {
+        for (const path of item.paths ?? []) {
+            const normalized = normalizePath(path);
+            for (const [rule, re] of compiled.paths)
+                if (re.test(normalized))
+                    add('path', item.subject, rule);
+        }
+        if (item.text === undefined)
+            continue;
+        const text = item.text.length > MAX_SCAN_CHARS ? item.text.slice(0, MAX_SCAN_CHARS) : item.text;
+        const folded = fold(text);
+        const lower = text.toLowerCase();
+        const packed = compiled.canaries.length ? compact(text) : '';
+        for (const [rule, forms, encoded] of compiled.canaries)
+            if (forms.some((f) => folded.includes(f) || lower.includes(f)) ||
+                encoded.some((f) => packed.includes(f)))
+                add('canary', item.subject, rule);
+        for (const [rule, content] of compiled.protectedContents)
+            if (folded.includes(content))
+                add('protected-content', item.subject, rule);
+        for (const [rule, re] of compiled.markers)
+            if (re.test(folded) || re.test(text))
+                add('marker', item.subject, rule);
+        for (const [rule, secret] of compiled.secrets)
+            if (text.includes(secret))
+                add('secret', item.subject, rule);
+        const unzeroed = stripZeroWidth(text);
+        for (const [name, re] of DEFAULT_SECRETS)
+            if (re.test(text) || re.test(unzeroed))
+                add('secret', item.subject, `default:${name}`);
+        if (compiled.paths.length) {
+            for (const token of pathTokens(text))
+                for (const [rule, re] of compiled.paths)
+                    if (re.test(token))
+                        add('path', item.subject, rule);
+        }
+    }
+    return findings;
+}
+/** @experimental Throws {@link LearningLeakError} when any subject carries evaluator-side material. */
+export function assertNoLearningLeak(guard, subjects) {
+    const findings = scanForLearningLeak(guard, subjects);
+    if (findings.length)
+        throw new LearningLeakError(findings);
+}
+function describeLeak(findings) {
+    const where = findings
+        .slice(0, 6)
+        .map((f) => `${f.subject} (${f.kind}, ${f.rule})`)
+        .join('; ');
+    const more = findings.length > 6 ? `; and ${findings.length - 6} more` : '';
+    return `Leak refused: evaluator-side material reached the learning input or output at ${where}${more}. This is a leak, not a false positive. Nothing was built from it, and the matched text is not repeated here. Remove it from the evidence source or the evaluator data location and rerun.`;
+}
+//# sourceMappingURL=leak-tripwire.js.map

package/dist/learning/leak-tripwire.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"leak-tripwire.js","sourceRoot":"","sources":["../../src/learning/leak-tripwire.ts"],"names":[],"mappings":"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"}

package/dist/{manager/resident/learning-observation.d.ts → learning/observation.d.ts}

@@ -72,14 +72,14 @@ export declare const learningObservationSchema: z.ZodObject<{
     taskKey: string;
 }>;
 /** @experimental Host-scored observation; failures need retained traces and a versioned evaluator. */
-export type ResidentLearningObservation = Readonly<Omit<z.infer<typeof learningObservationSchema>, 'evidence'>> & {
+export type LearningObservation = Readonly<Omit<z.infer<typeof learningObservationSchema>, 'evidence'>> & {
     readonly evidence: Readonly<z.infer<typeof learningObservationSchema>['evidence']>;
 };
 /** @experimental Current evaluator and installed skill revision authorized for one experiment. */
-export type ResidentLearningTarget = Readonly<z.infer<typeof learningTargetSchema>>;
+export type LearningTarget = Readonly<z.infer<typeof learningTargetSchema>>;
 /** @experimental Stable insertion order; a claimed cycle may have no live executor. */
-export interface ResidentLearningObservationRecord extends ResidentLearningObservation {
+export interface LearningObservationRecord extends LearningObservation {
     readonly ordinal: number;
     readonly attemptedCycleId: string | null;
 }
-//# sourceMappingURL=learning-observation.d.ts.map
+//# sourceMappingURL=observation.d.ts.map

package/dist/learning/observation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation.d.ts","sourceRoot":"","sources":["../../src/learning/observation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAA;AAOF,eAAO,MAAM,yBAAyB;;;;;IACrC,qDAAqD;;IAErD,gFAAgF;;IAEhF,wFAAwF;;;IAGxF,wFAAwF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIvF,CAAA;AAEF,sGAAsG;AACtG,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CACzC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,EAAE,UAAU,CAAC,CAC3D,GAAG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC,UAAU,CAAC,CAAC,CAAA;CAClF,CAAA;AAED,kGAAkG;AAClG,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAA;AAE3E,uFAAuF;AACvF,MAAM,WAAW,yBAA0B,SAAQ,mBAAmB;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;CACxC"}

package/dist/{manager/resident/learning-observation.js → learning/observation.js}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { residentLearningEvidenceSchema } from './learning.js';
+import { learningEvidenceSchema } from './skill.js';
 const label = z.string().trim().min(1).max(256);
 export const learningTargetSchema = z.object({
     skillName: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/),
@@ -20,7 +20,7 @@ export const learningObservationSchema = learningTargetSchema.extend({
     outcome: z.enum(['passed', 'failed', 'execution-error', 'unresolved']),
     /** Host verified all execution receipts have settled. This is not a model assertion. */
     usageComplete: z.boolean(),
-    evidence: residentLearningEvidenceSchema,
+    evidence: learningEvidenceSchema,
     trace: z.string().trim().min(1).max(32_000),
 });
-//# sourceMappingURL=learning-observation.js.map
+//# sourceMappingURL=observation.js.map

package/dist/learning/observation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation.js","sourceRoot":"","sources":["../../src/learning/observation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAEnD,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAC/C,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,4BAA4B,CAAC;IACzD,iBAAiB,EAAE,KAAK;IACxB,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC;CAClF,CAAC,CAAA;AAEF,MAAM,SAAS,GAAG,CAAC;KACjB,MAAM,EAAE;KACR,IAAI,EAAE;KACN,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,CAAA;AAErC,MAAM,CAAC,MAAM,yBAAyB,GAAG,oBAAoB,CAAC,MAAM,CAAC;IACpE,qDAAqD;IACrD,SAAS,EAAE,SAAS;IACpB,gFAAgF;IAChF,MAAM,EAAE,SAAS;IACjB,wFAAwF;IACxF,OAAO,EAAE,KAAK;IACd,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,iBAAiB,EAAE,YAAY,CAAC,CAAC;IACtE,wFAAwF;IACxF,aAAa,EAAE,CAAC,CAAC,OAAO,EAAE;IAC1B,QAAQ,EAAE,sBAAsB;IAChC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC;CAC3C,CAAC,CAAA"}

package/dist/{manager/resident/learning.d.ts → learning/skill.d.ts}

@@ -1,7 +1,7 @@
 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<{
+import { type HarnessProtectionPlan } from '../eval/harness-protection.js';
+import { type HarnessVerificationBatch } from '../eval/harness-verification.js';
+export declare const learningEvidenceSchema: z.ZodObject<{
     key: z.ZodString;
     source: z.ZodString;
     reason: z.ZodString;
@@ -15,7 +15,7 @@ export declare const residentLearningEvidenceSchema: z.ZodObject<{
     source: string;
 }>;
 /** @experimental Host provenance for a correction, evaluated activation or rollback. */
-export type ResidentLearningEvidence = Readonly<z.infer<typeof residentLearningEvidenceSchema>>;
+export type LearningEvidence = Readonly<z.infer<typeof learningEvidenceSchema>>;
 declare const sourceSchema: z.ZodObject<{
     key: z.ZodString;
     revision: z.ZodString;
@@ -27,7 +27,7 @@ declare const sourceSchema: z.ZodObject<{
     revision: string;
 }>;
 /** @experimental Host-owned source identity and revision; neither is a model assertion. */
-export type ResidentLearningSource = Readonly<z.infer<typeof sourceSchema>>;
+export type LearningSource = Readonly<z.infer<typeof sourceSchema>>;
 declare const candidateSchema: z.ZodObject<{
     name: z.ZodString;
     /** Omitted means ordinary task guidance; exploration policies require explicit projection. */
@@ -77,11 +77,11 @@ declare const candidateSchema: z.ZodObject<{
     }[] | undefined;
 }>;
 /** @experimental Instructional guidance only; never executable assets or tool permissions. */
-export type ResidentSkillCandidate = Readonly<Omit<z.infer<typeof candidateSchema>, 'sources'>> & {
-    readonly sources?: readonly ResidentLearningSource[];
+export type LearningSkillCandidate = Readonly<Omit<z.infer<typeof candidateSchema>, 'sources'>> & {
+    readonly sources?: readonly LearningSource[];
 };
 /** Internal canonical snapshot, including immutable source bindings. */
-export declare function normalizeResidentSkill(input: ResidentSkillCandidate): ResidentSkillCandidate;
+export declare function normalizeLearningSkill(input: LearningSkillCandidate): LearningSkillCandidate;
 declare const learnedSkillSchema: z.ZodObject<{
     name: z.ZodString;
     /** Omitted means ordinary task guidance; exploration policies require explicit projection. */
@@ -225,10 +225,10 @@ declare const learnedSkillSchema: z.ZodObject<{
     }[] | undefined;
 }>;
 /** @experimental Immutable evaluated content and evidence identity. */
-export type ResidentLearnedSkill = Readonly<Omit<z.infer<typeof learnedSkillSchema>, 'sources'>> & {
-    readonly sources?: readonly ResidentLearningSource[];
+export type LearnedSkill = Readonly<Omit<z.infer<typeof learnedSkillSchema>, 'sources'>> & {
+    readonly sources?: readonly LearningSource[];
 };
-export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
+export declare const learningSchema: z.ZodEffects<z.ZodObject<{
     revision: z.ZodNumber;
     identity: z.ZodOptional<z.ZodObject<{
         text: z.ZodString;
@@ -658,58 +658,58 @@ export declare const residentLearningSchema: z.ZodEffects<z.ZodObject<{
     } | undefined;
 }>;
 /** @experimental Versioned behavioral overlay; the original resident mandate remains unchanged. */
-export interface ResidentLearningState {
+export interface LearningState {
     readonly revision: number;
     readonly identity?: {
         readonly text: string;
-        readonly evidence: ResidentLearningEvidence;
+        readonly evidence: LearningEvidence;
     };
     readonly preferences: readonly {
         readonly key: string;
         readonly value: string;
-        readonly evidence: ResidentLearningEvidence;
+        readonly evidence: LearningEvidence;
     }[];
-    readonly skills: readonly ResidentLearnedSkill[];
-    readonly lastChange: ResidentLearningEvidence;
+    readonly skills: readonly LearnedSkill[];
+    readonly lastChange: LearningEvidence;
 }
 /** @experimental Corrections name the current preference evidence they supersede. */
-export interface ResidentProfileUpdate {
+export interface LearningProfileUpdate {
     readonly identity?: string;
     readonly preferences?: readonly {
         readonly key: string;
         readonly value: string;
         readonly supersedes: string | null;
     }[];
-    readonly evidence: ResidentLearningEvidence;
+    readonly evidence: LearningEvidence;
 }
 /** @experimental Recorded paired runs; hosts own execution, scoring and independent attribution. */
-export interface ResidentSkillEvaluation {
+export interface LearningSkillEvaluation {
     /** Host-owned task selection fixed before generating the candidate. */
     readonly protection: HarnessProtectionPlan;
     readonly verification: HarnessVerificationBatch;
     readonly confirmation?: HarnessVerificationBatch;
 }
 /** Internal immutable snapshot used by storage and admitted context. */
-export declare function freezeResidentLearning(input: ResidentLearningState): ResidentLearningState;
+export declare function freezeLearning(input: LearningState): LearningState;
 /** Internal pure profile transition; storage owns exact agenda CAS and idle admission. */
-export declare function reviseResidentProfile(current: ResidentLearningState | undefined, input: ResidentProfileUpdate): ResidentLearningState;
+export declare function reviseLearningProfile(current: LearningState | undefined, input: LearningProfileUpdate): LearningState;
 /** @experimental Bind evaluation to normalized content and any declared source dependencies. */
-export declare function hashResidentSkill(input: ResidentSkillCandidate): string;
+export declare function hashLearningSkill(input: LearningSkillCandidate): 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;
+export declare function promoteLearningSkill(current: LearningState | undefined, input: LearningSkillCandidate, evaluation: LearningSkillEvaluation, inputEvidence: LearningEvidence): LearningState;
 /** Internal rollback appends a new learning version while preserving current profile values. */
-export declare function restoreResidentSkill(current: ResidentLearningState | undefined, historical: ResidentLearningState | undefined, skillName: string, inputEvidence: ResidentLearningEvidence): ResidentLearningState;
+export declare function restoreLearningSkill(current: LearningState | undefined, historical: LearningState | undefined, skillName: string, inputEvidence: LearningEvidence): LearningState;
 /** @experimental Exact skill selection and a character cap, independent of provider token budgets. */
-export interface ResidentLearningProjectionOptions {
+export interface LearningProjectionOptions {
     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[];
+    readonly sources?: readonly LearningSource[];
 }
 /** @experimental Omitted entries are counted; no partial skill instruction is emitted. */
-export interface ResidentLearningProjection {
+export interface LearningProjection {
     readonly text: string;
     readonly revision: number | null;
     readonly includedSkills: readonly string[];
@@ -721,6 +721,6 @@ export interface ResidentLearningProjection {
     }[];
 }
 /** @experimental Bounded context data; never registers tools, loads files or executes a skill. */
-export declare function projectResidentLearning(current: ResidentLearningState | undefined, options: ResidentLearningProjectionOptions): ResidentLearningProjection;
+export declare function projectLearning(current: LearningState | undefined, options: LearningProjectionOptions): LearningProjection;
 export {};
-//# sourceMappingURL=learning.d.ts.map
+//# sourceMappingURL=skill.d.ts.map

package/dist/learning/skill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../src/learning/skill.ts"],"names":[],"mappings":"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"}

package/dist/{manager/resident/learning.js → learning/skill.js}

@@ -1,11 +1,11 @@
 import { createHash } from 'node:crypto';
 import { z } from 'zod';
-import { normalizeHarnessProtection, } from '../../eval/harness-protection.js';
-import { reviewHarnessCandidate, } from '../../eval/harness-verification.js';
+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}$/);
 const digest = z.string().regex(/^[a-f0-9]{64}$/);
-export const residentLearningEvidenceSchema = z.object({
+export const learningEvidenceSchema = z.object({
     key: label,
     source: label,
     reason: z.string().trim().min(1).max(1_000),
@@ -30,7 +30,7 @@ const candidateSchema = z.object({
     sources: sourcesSchema.optional(),
 });
 /** Internal canonical snapshot, including immutable source bindings. */
-export function normalizeResidentSkill(input) {
+export function normalizeLearningSkill(input) {
     const candidate = candidateSchema.parse(input);
     return Object.freeze({
         ...candidate,
@@ -41,7 +41,7 @@ export function normalizeResidentSkill(input) {
 }
 const learnedSkillSchema = candidateSchema.extend({
     hash: digest,
-    evidence: residentLearningEvidenceSchema,
+    evidence: learningEvidenceSchema,
     verification: z.object({
         baselineHash: z.union([digest, z.literal('none')]),
         candidateHash: digest,
@@ -58,29 +58,29 @@ const learnedSkillSchema = candidateSchema.extend({
             .optional(),
     }),
 });
-export const residentLearningSchema = z
+export const learningSchema = z
     .object({
     revision: z.number().int().positive().safe(),
     identity: z
         .object({
         text: z.string().trim().min(1).max(4_000),
-        evidence: residentLearningEvidenceSchema,
+        evidence: learningEvidenceSchema,
     })
         .optional(),
     preferences: z
         .array(z.object({
         key: name,
         value: z.string().trim().min(1).max(1_000),
-        evidence: residentLearningEvidenceSchema,
+        evidence: learningEvidenceSchema,
     }))
         .max(32),
     skills: z.array(learnedSkillSchema).max(16),
-    lastChange: residentLearningEvidenceSchema,
+    lastChange: learningEvidenceSchema,
 })
     .superRefine((state, context) => {
     if (new Set(state.preferences.map((p) => p.key)).size !== state.preferences.length ||
         new Set(state.skills.map((s) => s.name)).size !== state.skills.length ||
-        state.skills.some((skill) => skill.hash !== hashResidentSkill(skill) ||
+        state.skills.some((skill) => skill.hash !== hashLearningSkill(skill) ||
             skill.verification.candidateHash !== skill.hash))
         context.addIssue({
             code: z.ZodIssueCode.custom,
@@ -88,8 +88,8 @@ export const residentLearningSchema = z
         });
 });
 /** Internal immutable snapshot used by storage and admitted context. */
-export function freezeResidentLearning(input) {
-    const state = residentLearningSchema.parse(input);
+export function freezeLearning(input) {
+    const state = learningSchema.parse(input);
     return Object.freeze({
         ...state,
         ...(state.identity
@@ -118,7 +118,7 @@ export function freezeResidentLearning(input) {
     });
 }
 function evidenceFor(current, input) {
-    const evidence = residentLearningEvidenceSchema.parse(input);
+    const evidence = learningEvidenceSchema.parse(input);
     const used = [
         current?.lastChange,
         current?.identity?.evidence,
@@ -130,7 +130,7 @@ function evidenceFor(current, input) {
     return evidence;
 }
 function base(current, evidence) {
-    const checked = current ? freezeResidentLearning(current) : undefined;
+    const checked = current ? freezeLearning(current) : undefined;
     return {
         ...checked,
         revision: (checked?.revision ?? 0) + 1,
@@ -140,7 +140,7 @@ function base(current, evidence) {
     };
 }
 /** Internal pure profile transition; storage owns exact agenda CAS and idle admission. */
-export function reviseResidentProfile(current, input) {
+export function reviseLearningProfile(current, input) {
     const checked = z
         .object({
         identity: z.string().trim().min(1).max(4_000).optional(),
@@ -152,7 +152,7 @@ export function reviseResidentProfile(current, input) {
         }))
             .max(32)
             .optional(),
-        evidence: residentLearningEvidenceSchema,
+        evidence: learningEvidenceSchema,
     })
         .parse(input);
     if (checked.identity === undefined && !checked.preferences?.length)
@@ -174,14 +174,14 @@ export function reviseResidentProfile(current, input) {
         else
             preferences[index] = updated;
     }
-    return freezeResidentLearning({
+    return freezeLearning({
         ...next,
         preferences,
         ...(checked.identity !== undefined ? { identity: { text: checked.identity, evidence } } : {}),
     });
 }
 /** @experimental Bind evaluation to normalized content and any declared source dependencies. */
-export function hashResidentSkill(input) {
+export function hashLearningSkill(input) {
     const candidate = candidateSchema.parse(input);
     return createHash('sha256')
         .update(JSON.stringify([
@@ -194,10 +194,10 @@ export function hashResidentSkill(input) {
         .digest('hex');
 }
 /** Internal pure activation; reuse the kernel's conservative two-round verification gate. */
-export function promoteResidentSkill(current, input, evaluation, inputEvidence) {
+export function promoteLearningSkill(current, input, evaluation, inputEvidence) {
     const protection = normalizeHarnessProtection(evaluation.protection);
     const candidate = candidateSchema.parse(input);
-    const hash = hashResidentSkill(candidate);
+    const hash = hashLearningSkill(candidate);
     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.');
@@ -242,27 +242,27 @@ export function promoteResidentSkill(current, input, evaluation, inputEvidence)
         },
     };
     const next = base(current, evidence);
-    return freezeResidentLearning({
+    return freezeLearning({
         ...next,
         skills: [...next.skills.filter((s) => s.name !== candidate.name), skill],
     });
 }
 /** Internal rollback appends a new learning version while preserving current profile values. */
-export function restoreResidentSkill(current, historical, skillName, inputEvidence) {
+export function restoreLearningSkill(current, historical, skillName, inputEvidence) {
     name.parse(skillName);
     if (!current?.skills.some((s) => s.name === skillName))
         throw new Error('No active resident skill to roll back.');
     const next = base(current, evidenceFor(current, inputEvidence));
     const previous = historical
-        ? freezeResidentLearning(historical).skills.find((s) => s.name === skillName)
+        ? freezeLearning(historical).skills.find((s) => s.name === skillName)
         : undefined;
-    return freezeResidentLearning({
+    return freezeLearning({
         ...next,
         skills: [...next.skills.filter((s) => s.name !== skillName), ...(previous ? [previous] : [])],
     });
 }
 /** @experimental Bounded context data; never registers tools, loads files or executes a skill. */
-export function projectResidentLearning(current, options) {
+export function projectLearning(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);
@@ -284,7 +284,7 @@ export function projectResidentLearning(current, options) {
             omitted: selected.length,
             withheldSkills: Object.freeze([]),
         });
-    const state = freezeResidentLearning(current);
+    const state = freezeLearning(current);
     const pieces = [];
     const includedSkills = [];
     const withheldSkills = [];
@@ -350,4 +350,4 @@ export function projectResidentLearning(current, options) {
         withheldSkills: Object.freeze(withheldSkills),
     });
 }
-//# sourceMappingURL=learning.js.map
+//# sourceMappingURL=skill.js.map