sneakoscope 6.2.0 → 6.4.0

package/dist/core/safety/command-contract/contracts.js

@@ -0,0 +1,210 @@
+import { COMMANDS } from '../../../cli/command-registry.js';
+const ARGUMENT_PROFILES = {
+    none: {
+        schema: objectSchema({}),
+        build: () => []
+    },
+    'json-only': {
+        schema: objectSchema({ json: { type: 'boolean' } }),
+        build: jsonFlag
+    },
+    paths: {
+        schema: objectSchema({
+            action: { type: 'string', enum: ['managed', 'git-policy'] },
+            json: { type: 'boolean' }
+        }),
+        build: (input) => [stringValue(input.action, 'managed'), ...jsonFlag(input)]
+    },
+    'pipeline-status': {
+        schema: objectSchema({
+            action: { type: 'string', enum: ['status'] },
+            json: { type: 'boolean' }
+        }),
+        build: (input) => [stringValue(input.action, 'status'), ...jsonFlag(input)]
+    },
+    stats: {
+        schema: objectSchema({ full: { type: 'boolean' }, json: { type: 'boolean' } }),
+        build: (input) => [...booleanFlag(input, 'full', '--full'), ...jsonFlag(input)]
+    },
+    'stop-gate': {
+        schema: objectSchema({
+            route: boundedString(1, 80),
+            mission: boundedString(1, 160),
+            gate: boundedString(1, 1024),
+            json: { type: 'boolean' }
+        }),
+        build: (input) => [
+            'check',
+            ...valueFlag(input, 'route', '--route'),
+            ...valueFlag(input, 'mission', '--mission'),
+            ...valueFlag(input, 'gate', '--gate'),
+            ...jsonFlag(input)
+        ]
+    },
+    proof: {
+        schema: objectSchema({
+            action: { type: 'string', enum: ['show', 'latest', 'validate', 'route'] },
+            mission: boundedString(1, 160),
+            completion: { type: 'boolean' },
+            json: { type: 'boolean' }
+        }),
+        build: (input) => {
+            const action = stringValue(input.action, 'show');
+            const mission = typeof input.mission === 'string' && action === 'route' ? [input.mission] : [];
+            return [action, ...mission, ...booleanFlag(input, 'completion', '--completion'), ...jsonFlag(input)];
+        }
+    },
+    trust: {
+        schema: objectSchema({
+            action: { type: 'string', enum: ['report', 'status', 'explain'] },
+            mission: boundedString(1, 160),
+            json: { type: 'boolean' }
+        }),
+        build: (input) => [
+            stringValue(input.action, 'status'),
+            ...(typeof input.mission === 'string' ? [input.mission] : []),
+            ...jsonFlag(input)
+        ]
+    },
+    gates: {
+        schema: objectSchema({
+            target: boundedString(1, 120),
+            mode: { type: 'string', enum: ['preset', 'gate'] },
+            full: { type: 'boolean' },
+            json: { type: 'boolean' }
+        }),
+        build: (input) => {
+            const target = stringValue(input.target, 'affected');
+            const selector = input.mode === 'gate' ? ['--gate', target] : ['--preset', target];
+            return ['run', ...selector, ...booleanFlag(input, 'full', '--full'), ...jsonFlag(input)];
+        }
+    },
+    'validate-artifacts': {
+        schema: objectSchema({
+            mission: boundedString(1, 160),
+            required: {
+                type: 'array',
+                items: boundedString(1, 80),
+                maxItems: 32
+            },
+            json: { type: 'boolean' }
+        }),
+        build: (input) => [
+            ...(typeof input.mission === 'string' ? [input.mission] : []),
+            ...(Array.isArray(input.required) && input.required.length > 0 ? ['--required', input.required.join(',')] : []),
+            ...jsonFlag(input)
+        ]
+    }
+};
+function objectSchema(properties) {
+    return { type: 'object', properties, additionalProperties: false };
+}
+function boundedString(minLength, maxLength) {
+    return { type: 'string', minLength, maxLength };
+}
+function stringValue(value, fallback) {
+    return typeof value === 'string' ? value : fallback;
+}
+function jsonFlag(input) {
+    return input.json === true ? ['--json'] : [];
+}
+function booleanFlag(input, key, flag) {
+    return input[key] === true ? [flag] : [];
+}
+function valueFlag(input, key, flag) {
+    return typeof input[key] === 'string' ? [flag, input[key]] : [];
+}
+function maturityFor(command) {
+    return command.maturity === 'beta' ? 'preview' : command.maturity;
+}
+function buildContract(name, command) {
+    const profile = ARGUMENT_PROFILES[command.inputProfile];
+    const r3Denied = command.risk === 'R3';
+    const remoteAllowed = !r3Denied && command.remoteAllowed;
+    return {
+        schema: 'sks.command-contract.v2',
+        name,
+        description: command.summary,
+        maturity: maturityFor(command),
+        read_only: command.risk === 'R0',
+        risk: command.risk,
+        latency: command.latency,
+        supports_json: command.supportsJson,
+        remote_allowed: remoteAllowed,
+        telegram_allowed: remoteAllowed && command.telegramAllowed,
+        input_schema: profile.schema,
+        argv_builder: (input) => [name, ...profile.build((input ?? {}))],
+        required_capabilities: [...command.requiredCapabilities]
+    };
+}
+let cachedContracts = null;
+export function commandContracts() {
+    if (cachedContracts)
+        return cachedContracts;
+    cachedContracts = new Map(Object.keys(COMMANDS)
+        .sort()
+        .map((name) => [name, buildContract(name, COMMANDS[name])]));
+    return cachedContracts;
+}
+export function commandContract(name) {
+    return commandContracts().get(name) ?? null;
+}
+export function validateCommandContractRegistry() {
+    const expectedNames = Object.keys(COMMANDS).sort();
+    const contracts = commandContracts();
+    const observedNames = [...contracts.keys()].sort();
+    const issues = [];
+    for (const name of expectedNames) {
+        const command = COMMANDS[name];
+        const contract = contracts.get(name);
+        if (!contract) {
+            issues.push(`missing_contract:${name}`);
+            continue;
+        }
+        if (contract.schema !== 'sks.command-contract.v2')
+            issues.push(`invalid_schema:${name}`);
+        if (contract.name !== name)
+            issues.push(`name_mismatch:${name}`);
+        if (contract.risk !== command.risk)
+            issues.push(`risk_mismatch:${name}`);
+        if (contract.latency !== command.latency)
+            issues.push(`latency_mismatch:${name}`);
+        if (contract.supports_json !== command.supportsJson)
+            issues.push(`json_support_mismatch:${name}`);
+        if (command.risk === 'R3' && (command.remoteAllowed || command.telegramAllowed))
+            issues.push(`r3_metadata_exposed:${name}`);
+        if (contract.risk === 'R3' && (contract.remote_allowed || contract.telegram_allowed))
+            issues.push(`r3_exposed:${name}`);
+        if (command.telegramAllowed && !command.remoteAllowed)
+            issues.push(`telegram_metadata_without_remote:${name}`);
+        if (contract.telegram_allowed && !contract.remote_allowed)
+            issues.push(`telegram_without_remote:${name}`);
+        if (contract.input_schema.type !== 'object' || contract.input_schema.additionalProperties !== false)
+            issues.push(`unsafe_schema:${name}`);
+        if (command.supportsJson && command.inputProfile === 'none')
+            issues.push(`json_support_without_input_profile:${name}`);
+        if (command.inputProfile !== 'none' && !command.supportsJson)
+            issues.push(`profile_without_json_support:${name}`);
+        if (command.remoteAllowed && command.inputProfile === 'none')
+            issues.push(`remote_without_input_profile:${name}`);
+    }
+    for (const name of observedNames) {
+        if (!(name in COMMANDS))
+            issues.push(`unexpected_contract:${name}`);
+    }
+    return { ok: issues.length === 0, issues, expected_names: expectedNames, observed_names: observedNames };
+}
+export function timeoutFor(latency) {
+    if (latency === 'fast')
+        return 15_000;
+    if (latency === 'normal')
+        return 60_000;
+    return 180_000;
+}
+export function outputCapFor(latency) {
+    if (latency === 'fast')
+        return 128 * 1024;
+    if (latency === 'normal')
+        return 512 * 1024;
+    return 1024 * 1024;
+}

package/dist/core/safety/command-contract/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './json-schema.js';
+export * from './contracts.js';

package/dist/core/safety/command-contract/json-schema.js

@@ -0,0 +1,91 @@
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function issue(path, code, message) {
+    return { path, code, message };
+}
+function matchesType(value, type) {
+    if (type === 'object')
+        return isObject(value);
+    if (type === 'array')
+        return Array.isArray(value);
+    if (type === 'integer')
+        return typeof value === 'number' && Number.isInteger(value);
+    if (type === 'number')
+        return typeof value === 'number' && Number.isFinite(value);
+    if (type === 'null')
+        return value === null;
+    return typeof value === type;
+}
+function validateNode(value, schema, path, issues) {
+    const expectedType = typeof schema.type === 'string' ? schema.type : null;
+    if (expectedType && !matchesType(value, expectedType)) {
+        issues.push(issue(path, 'type', `Expected ${expectedType}`));
+        return value;
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.some((candidate) => Object.is(candidate, value))) {
+        issues.push(issue(path, 'enum', 'Value is not one of the allowed values'));
+    }
+    if (typeof value === 'string') {
+        if (typeof schema.minLength === 'number' && value.length < schema.minLength) {
+            issues.push(issue(path, 'minLength', `String must contain at least ${schema.minLength} characters`));
+        }
+        if (typeof schema.maxLength === 'number' && value.length > schema.maxLength) {
+            issues.push(issue(path, 'maxLength', `String must contain at most ${schema.maxLength} characters`));
+        }
+        if (typeof schema.pattern === 'string' && !new RegExp(schema.pattern, 'u').test(value)) {
+            issues.push(issue(path, 'pattern', 'String does not match the required pattern'));
+        }
+    }
+    if (typeof value === 'number') {
+        if (typeof schema.minimum === 'number' && value < schema.minimum) {
+            issues.push(issue(path, 'minimum', `Number must be at least ${schema.minimum}`));
+        }
+        if (typeof schema.maximum === 'number' && value > schema.maximum) {
+            issues.push(issue(path, 'maximum', `Number must be at most ${schema.maximum}`));
+        }
+    }
+    if (Array.isArray(value)) {
+        if (typeof schema.minItems === 'number' && value.length < schema.minItems) {
+            issues.push(issue(path, 'minItems', `Array must contain at least ${schema.minItems} items`));
+        }
+        if (typeof schema.maxItems === 'number' && value.length > schema.maxItems) {
+            issues.push(issue(path, 'maxItems', `Array must contain at most ${schema.maxItems} items`));
+        }
+        const itemSchema = isObject(schema.items) ? schema.items : null;
+        return itemSchema
+            ? value.map((entry, index) => validateNode(entry, itemSchema, `${path}/${index}`, issues))
+            : [...value];
+    }
+    if (!isObject(value))
+        return value;
+    const properties = isObject(schema.properties) ? schema.properties : {};
+    const required = Array.isArray(schema.required) ? schema.required.map(String) : [];
+    const normalized = {};
+    for (const name of required) {
+        if (!(name in value))
+            issues.push(issue(`${path}/${name}`, 'required', 'Required property is missing'));
+    }
+    for (const [name, childValue] of Object.entries(value)) {
+        const childSchema = properties[name];
+        if (!isObject(childSchema)) {
+            if (schema.additionalProperties === false) {
+                issues.push(issue(`${path}/${name}`, 'additionalProperties', 'Unknown property is not allowed'));
+            }
+            else {
+                normalized[name] = childValue;
+            }
+            continue;
+        }
+        normalized[name] = validateNode(childValue, childSchema, `${path}/${name}`, issues);
+    }
+    return normalized;
+}
+export function validateJsonSchema(input, schema) {
+    const value = input === undefined || input === null ? {} : input;
+    const issues = [];
+    const normalized = validateNode(value, schema, '$', issues);
+    if (issues.length > 0 || !isObject(normalized))
+        return { ok: false, value: null, issues };
+    return { ok: true, value: normalized, issues: [] };
+}

package/dist/core/safety/command-contract/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/safety/mutation-guard.js

@@ -189,4 +189,3 @@ export function guardContextForRoute(root, contract, reason) {
         ctx.reason = reason;
     return ctx;
 }
-//# sourceMappingURL=mutation-guard.js.map

package/dist/core/safety/mutation-ledger.js

@@ -74,4 +74,3 @@ export async function recordMutation(root, entry) {
     await appendJsonl(file, entry);
     return file;
 }
-//# sourceMappingURL=mutation-ledger.js.map

package/dist/core/safety/side-effect-runtime-report.js

@@ -96,4 +96,3 @@ async function readLedger(file) {
         }
     });
 }
-//# sourceMappingURL=side-effect-runtime-report.js.map

package/dist/core/safety/ssot-guard.js

@@ -30,14 +30,14 @@ export function buildSsotGuard(input = {}) {
         ],
         required_checks: [
             'pipeline_plan_contains_ssot_guard_stage',
-            'team_plan_requires_ssot_guard_artifact',
-            'team_gate_requires_ssot_guard_true',
+            'naruto_plan_requires_ssot_guard_artifact',
+            'naruto_gate_requires_ssot_guard_true',
             'stop_gate_validates_ssot_guard_artifact',
             'release_dag_runs_ssot_guard',
             'release_dag_runs_architecture_guard',
             'release_manifest_marks_architecture_guard_p0_and_publish_required'
         ],
-        gate_rule: `${SSOT_GUARD_ARTIFACT} must validate SSOT and SOLID expectations before a Team gate may set ssot_guard=true.`
+        gate_rule: `${SSOT_GUARD_ARTIFACT} must validate SSOT and SOLID expectations before a Naruto gate may set ssot_guard=true.`
     };
 }
 export function canonicalSsotSources() {
@@ -46,14 +46,14 @@ export function canonicalSsotSources() {
             id: 'route_contract',
             source: 'decision-contract.json, route prompt, and pipeline-plan.json',
             authority: 'The sealed user objective, constraints, non-goals, and acceptance criteria define what code may be created.',
-            derived: ['team-plan.json', 'team-runtime-tasks.json', 'worker inboxes'],
+            derived: ['subagent-plan.json', 'subagent-events.jsonl', 'worker inboxes'],
             rule: 'Do not implement behavior outside the sealed route contract; block with evidence if the requested path cannot be honored.'
         },
         {
             id: 'triwiki_context',
             source: '.sneakoscope/wiki/context-pack.json',
             authority: 'TriWiki is the bounded mission context SSOT and must be refreshed or packed, then validated before risky handoffs and final claims.',
-            derived: ['team-analysis.md', 'team-consensus.md', 'team-review.md'],
+            derived: ['subagent-parent-summary.json', 'subagent-evidence.json', 'reflection.md'],
             rule: 'Use the latest coordinate+voxel overlay pack; coordinate-only legacy packs are invalid for pipeline decisions.'
         },
         {
@@ -87,7 +87,7 @@ export function canonicalSsotSources() {
     ];
 }
 export function ssotGuardPolicyText(commandPrefix = 'sks') {
-    return `SSOT/SOLID guard: before creating or changing code, identify the authoritative source for the surface being edited, edit only that source, regenerate derived outputs, and reject duplicated or fallback behavior that would compete with the source of truth. Keep changes aligned to SOLID by preserving single responsibility, extension boundaries, substitutable adapters, narrow interfaces, and dependency inversion at existing seams. Team routes must write ${SSOT_GUARD_ARTIFACT}, set team-gate.json ssot_guard=true only after it validates, and run ${commandPrefix} wiki validate .sneakoscope/wiki/context-pack.json before final claims.`;
+    return `SSOT/SOLID guard: before creating or changing code, identify the authoritative source for the surface being edited, edit only that source, regenerate derived outputs, and reject duplicated or fallback behavior that would compete with the source of truth. Keep changes aligned to SOLID by preserving single responsibility, extension boundaries, substitutable adapters, narrow interfaces, and dependency inversion at existing seams. Naruto routes must write ${SSOT_GUARD_ARTIFACT}, set naruto-gate.json ssot_guard=true only after it validates, and run ${commandPrefix} wiki validate .sneakoscope/wiki/context-pack.json before final claims.`;
 }
 export function validateSsotGuardArtifact(value) {
     const issues = [];
@@ -127,7 +127,7 @@ export function validateSsotGuardArtifact(value) {
     if (stringArray(value.solid_risk_flags).length < 5)
         issues.push('solid_risk_flags');
     const checks = stringArray(value.required_checks);
-    for (const check of ['team_gate_requires_ssot_guard_true', 'stop_gate_validates_ssot_guard_artifact', 'release_dag_runs_ssot_guard', 'release_dag_runs_architecture_guard']) {
+    for (const check of ['naruto_gate_requires_ssot_guard_true', 'stop_gate_validates_ssot_guard_artifact', 'release_dag_runs_ssot_guard', 'release_dag_runs_architecture_guard']) {
         if (!checks.includes(check))
             issues.push(`required_checks:${check}`);
     }
@@ -170,4 +170,3 @@ function isRecord(value) {
 function stringArray(value) {
     return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
 }
-//# sourceMappingURL=ssot-guard.js.map

package/dist/core/search-visibility/adapter-registry.js

@@ -23,4 +23,3 @@ export function adapterForDetection(_detection) {
 export function searchVisibilityAdapters() {
     return [GENERIC_ADAPTER];
 }
-//# sourceMappingURL=adapter-registry.js.map

package/dist/core/search-visibility/adapters/next-app.js

@@ -3,4 +3,3 @@ export const NEXT_APP_SEARCH_VISIBILITY_SUPPORT = {
     sourceAudit: true,
     mutation: 'guarded_metadata_robots_sitemap_jsonld_when_source_patterns_are_unambiguous',
 };
-//# sourceMappingURL=next-app.js.map

package/dist/core/search-visibility/adapters/next-pages.js

@@ -3,4 +3,3 @@ export const NEXT_PAGES_SEARCH_VISIBILITY_SUPPORT = {
     sourceAudit: true,
     mutation: 'guarded_metadata_robots_sitemap_jsonld_when_source_patterns_are_unambiguous',
 };
-//# sourceMappingURL=next-pages.js.map

package/dist/core/search-visibility/adapters/static-site.js

@@ -3,4 +3,3 @@ export const STATIC_SITE_SEARCH_VISIBILITY_SUPPORT = {
     sourceAudit: true,
     mutation: 'create_only_policy_files_and_managed_head_blocks_when_ownership_is_clear',
 };
-//# sourceMappingURL=static-site.js.map

package/dist/core/search-visibility/analyzers.js

@@ -374,4 +374,3 @@ function routeFromHtmlPath(pathValue) {
 function slug(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 64) || 'item';
 }
-//# sourceMappingURL=analyzers.js.map

package/dist/core/search-visibility/artifacts.js

@@ -180,4 +180,3 @@ function countFindings(findings) {
         counts[finding.severity] = (counts[finding.severity] || 0) + 1;
     return counts;
 }
-//# sourceMappingURL=artifacts.js.map

package/dist/core/search-visibility/discovery.js

@@ -344,4 +344,3 @@ function stripTags(text) {
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-//# sourceMappingURL=discovery.js.map

package/dist/core/search-visibility/index.js

@@ -332,4 +332,3 @@ async function isZeroOperationMarketingPlan(mission, plan) {
     const present = await Promise.all(required.map((artifact) => exists(path.join(mission.artifactDir, artifact))));
     return present.every(Boolean);
 }
-//# sourceMappingURL=index.js.map

package/dist/core/search-visibility/marketing-truthfulness.js

@@ -45,7 +45,7 @@ export function evaluateMarketingTruthfulness(input) {
         if ((claim.claim_type === 'performance' || /p95|latency|performance|fast/i.test(text)) && !claim.source_ids.some((id) => /perf|budget|report/i.test(id))) {
             unsupported_claims.push(claim.id);
         }
-        if ((claim.claim_type === 'parallel' || /parallel|worker|clone|naruto/i.test(text)) && !claim.source_ids.some((id) => /parallel|naruto|agent|report/i.test(id))) {
+        if ((claim.claim_type === 'parallel' || /parallel|worker|naruto/i.test(text)) && !claim.source_ids.some((id) => /parallel|naruto|agent|report/i.test(id))) {
             unsupported_claims.push(claim.id);
         }
         if ((claim.claim_type === 'super_search' || /super-search|source-backed|source backed/i.test(text)) && !claim.source_ids.some((id) => /super-search|source|report/i.test(id))) {
@@ -131,7 +131,7 @@ function claimsFromStrategy(strategy) {
 export function classifyClaim(text) {
     if (/super-search|source-backed|source backed/i.test(text))
         return 'super_search';
-    if (/parallel|worker|clone|naruto/i.test(text))
+    if (/parallel|worker|naruto/i.test(text))
         return 'parallel';
     if (/p95|latency|performance|fast/i.test(text))
         return 'performance';
@@ -144,4 +144,3 @@ export function classifyClaim(text) {
 function unique(values) {
     return [...new Set(values.filter(Boolean))];
 }
-//# sourceMappingURL=marketing-truthfulness.js.map

package/dist/core/search-visibility/marketing.js

@@ -283,7 +283,7 @@ function scoreMarketingStrategy(strategy, truth) {
     else
         blockers.push('strategy_quality_forbidden_phrases_present');
     if (hasSupportedSpecialClaim(strategy, /p95|latency|performance|fast/i, /perf|budget|report/i)
-        && hasSupportedSpecialClaim(strategy, /parallel|worker|clone|naruto/i, /parallel|naruto|agent|report|routes/i)
+        && hasSupportedSpecialClaim(strategy, /parallel|worker|naruto/i, /parallel|naruto|agent|report|routes/i)
         && hasSupportedSpecialClaim(strategy, /super-search|source-backed|source backed/i, /super-search|source|report/i)) {
         score += 15;
     }
@@ -455,4 +455,3 @@ function summarizeSource(rel, text) {
 function unique(values) {
     return [...new Set(values.filter(Boolean))];
 }
-//# sourceMappingURL=marketing.js.map

package/dist/core/search-visibility/mission.js

@@ -64,4 +64,3 @@ export function findingsFileForMode(mode) {
 export function missionRel(missionId, artifact) {
     return `.sneakoscope/missions/${missionId}/${SEARCH_VISIBILITY_DIR}/${artifact}`;
 }
-//# sourceMappingURL=mission.js.map

package/dist/core/search-visibility/mutation.js

@@ -439,4 +439,3 @@ async function gitDirtyStatus(root, rel) {
         return '';
     return String(result.stdout || '').trim();
 }
-//# sourceMappingURL=mutation.js.map

package/dist/core/search-visibility/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/core/search-visibility/verifier.js

@@ -57,4 +57,3 @@ export function expectedArtifactPath(missionId, artifact) {
         return `.sneakoscope/missions/${missionId}/${artifact}`;
     return `.sneakoscope/missions/${missionId}/${SEARCH_VISIBILITY_DIR}/${artifact}`;
 }
-//# sourceMappingURL=verifier.js.map

package/dist/core/secret-redaction.js

@@ -76,4 +76,3 @@ function redactKeyValue(match) {
         return `Bearer ${REDACTION_MARKER}`;
     return REDACTION_MARKER;
 }
-//# sourceMappingURL=secret-redaction.js.map

package/dist/core/security/high-risk-contracts.js

@@ -285,4 +285,3 @@ function madSksBlockers(input) {
         blockers.push('mad_sks_read_back_proof_missing');
     return blockers;
 }
-//# sourceMappingURL=high-risk-contracts.js.map

package/dist/core/security/redact-secrets.js

@@ -12,4 +12,3 @@ export function redactOpenRouterSecrets(value, env = process.env) {
 export function redactOpenRouterString(value, env = process.env) {
     return redactString(String(value ?? ''), env);
 }
-//# sourceMappingURL=redact-secrets.js.map

package/dist/core/session/project-namespace.js

@@ -40,7 +40,7 @@ export function namespacedAgentSessionId(input) {
     const suffix = input.index === undefined ? '' : `-${String(input.index).padStart(2, '0')}`;
     return `${input.agentId}-${input.missionId}-${input.rootHash}${suffix}`;
 }
-export function namespacedZellijSessionName(namespace, label = 'team') {
+export function namespacedZellijSessionName(namespace, label = 'work') {
     const raw = `${namespace.zellij_prefix}-${label}`;
     return raw.replace(/[^A-Za-z0-9_.:-]+/g, '-').slice(0, 80);
 }
@@ -49,4 +49,3 @@ export async function writeProjectNamespaceArtifact(artifactRoot, namespace) {
     await writeJsonAtomic(file, namespace);
     return file;
 }
-//# sourceMappingURL=project-namespace.js.map

package/dist/core/skill-forge.js

@@ -27,7 +27,7 @@ const PROTECTED_SKILL_NAMES = new Set([
     'reasoning-router',
     'reflection',
     'sks',
-    'team',
+    'naruto',
     'wiki'
 ]);
 const MERGE_GROUPS = [
@@ -60,7 +60,7 @@ export function createSkillCandidate(opts = {}) {
         files: opts.files || []
     };
 }
-export function decideSkillInjection({ route = 'team', task_signature = '', skills = [], topK } = {}) {
+export function decideSkillInjection({ route = 'naruto', task_signature = '', skills = [], topK } = {}) {
     const k = Number(topK || (String(route).toLowerCase().includes('from-chat-img') ? 5 : 3));
     const ranked = skills
         .filter((skill) => skill.status === 'active' && !skill.stale && !skill.conflicting)
@@ -98,7 +98,7 @@ export function createSkillForgeReport(opts = {}) {
             && Number(candidate.quality_score || 0) >= 0.72
     }));
     const injection = decideSkillInjection({
-        route: opts.route || 'team',
+        route: opts.route || 'naruto',
         task_signature: opts.task_signature || '',
         skills: opts.skills || [],
         topK: opts.topK || 8
@@ -337,8 +337,8 @@ export async function skillDreamFixture(root) {
     await ensureDir(path.join(skillRoot, 'custom-keep'));
     await writeTextAtomic(path.join(skillRoot, 'custom-keep', 'SKILL.md'), '---\nname: custom-keep\ndescription: User custom skill, not generated by SKS.\n---\n');
     const opts = { policy: { min_events_between_runs: 2, min_interval_hours: 0 }, known_skill_names: ['used-generated', 'unused-generated'], protected_skill_names: ['used-generated'] };
-    await recordSkillDreamEvent(root, { route: 'team', command: '$Team', skills: ['used-generated'], prompt: 'fixture one' }, { ...opts, run_if_due: true });
-    const second = await recordSkillDreamEvent(root, { route: 'team', command: '$Team', skills: ['used-generated'], prompt: 'fixture two' }, { ...opts, run_if_due: true });
+    await recordSkillDreamEvent(root, { route: 'naruto', command: '$Naruto', skills: ['used-generated'], prompt: 'fixture one' }, { ...opts, run_if_due: true });
+    const second = await recordSkillDreamEvent(root, { route: 'naruto', command: '$Naruto', skills: ['used-generated'], prompt: 'fixture two' }, { ...opts, run_if_due: true });
     const report = second.report || await runSkillDream(root, { ...opts, force: true });
     return {
         passed: Boolean(report.no_auto_delete)
@@ -492,4 +492,3 @@ async function writeFixtureSkill(skillRoot, name, body) {
 function forgeSkillMarker(root) {
     return `<!-- BEGIN SKS FORGE SKILL project=${sha256(String(root || '')).slice(0, 12)} generator=sks@runtime created=${nowIso()} -->`;
 }
-//# sourceMappingURL=skill-forge.js.map

package/dist/core/skills/core-rollout-trace.js

@@ -30,4 +30,3 @@ export async function recordRolloutTrace(root, trace) {
     await appendJsonl(file, trace);
     return file;
 }
-//# sourceMappingURL=core-rollout-trace.js.map

package/dist/core/skills/core-skill-deployment.js

@@ -142,4 +142,3 @@ export async function hasRollbackSnapshot(root, route, skillId) {
     }
     return false;
 }
-//# sourceMappingURL=core-skill-deployment.js.map

package/dist/core/skills/core-skill-epoch.js

@@ -72,4 +72,3 @@ export async function runSkillEpoch(root, input) {
     const savedPath = await saveCard(root, accepted);
     return { accepted: true, reason: 'strict_improvement', patch_hash: hash, score_delta: heldout.score_delta, candidate: accepted, saved_path: savedPath };
 }
-//# sourceMappingURL=core-skill-epoch.js.map

package/dist/core/skills/core-skill-meta-update.js

@@ -21,4 +21,3 @@ export function metaUpdateLearningRate(rate, outcome, opts = {}) {
         max_replaced_chars: adjust(rate.max_replaced_chars, min.max_replaced_chars, max.max_replaced_chars)
     };
 }
-//# sourceMappingURL=core-skill-meta-update.js.map

package/dist/core/skills/core-skill-patch-apply.js

@@ -97,4 +97,3 @@ function addToSection(body, target, text) {
     const trimmed = body.replace(/\s+$/, '');
     return `${trimmed}\n\n## ${title}\n${text}\n`;
 }
-//# sourceMappingURL=core-skill-patch-apply.js.map

package/dist/core/skills/core-skill-patch.js

@@ -110,4 +110,3 @@ export function sectionSlug(value) {
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-+|-+$/g, '');
 }
-//# sourceMappingURL=core-skill-patch.js.map

package/dist/core/skills/core-skill-reflection.js

@@ -91,4 +91,3 @@ export function selectPatchOperations(card, aggregated, learningRate, opts = {})
     }
     return operations;
 }
-//# sourceMappingURL=core-skill-reflection.js.map

package/dist/core/skills/core-skill-runtime.js

@@ -36,4 +36,3 @@ export function skillProofRecord(selection) {
         deployment_context: isDeploymentContext()
     };
 }
-//# sourceMappingURL=core-skill-runtime.js.map

package/dist/core/skills/core-skill-scorer.js

@@ -75,4 +75,3 @@ export async function writeRolloutScore(root, score) {
     await writeJsonAtomic(file, { ...score, generated_at: nowIso() });
     return file;
 }
-//# sourceMappingURL=core-skill-scorer.js.map

package/dist/core/skills/core-skill-trainer.js

@@ -100,4 +100,3 @@ export async function trainSkill(root, input) {
         best_skill_path: bestSkillPath
     };
 }
-//# sourceMappingURL=core-skill-trainer.js.map