@native-knowledge/cli 0.1.0-rc.2 → 0.1.0-rc.4

package/dist/agent-entry-cli.js

@@ -44,6 +44,8 @@ export async function runAgentEntryCommand(command, flags, client) {
         if (flags.has('allow-insecure-http') && one('allow-insecure-http') !== 'true')
             throw new Error('AGENT_CLI_INPUT_INVALID');
         const tool = one('tool'), json = one('input-json'), file = one('input-file'), goal = one('goal'), guided = one('guided');
+        if (json !== undefined && Buffer.byteLength(json) > 131072)
+            throw new Error('AGENT_CLI_INPUT_BUDGET');
         if (guided !== undefined && (guided !== 'true' || command !== 'agent call') || goal !== undefined && command !== 'agent task')
             throw new Error('AGENT_CLI_INPUT_INVALID');
         if (command === 'agent task' || command === 'agent input') {

package/dist/cli.js

@@ -6,18 +6,23 @@ import path from 'node:path';
 import { KnowledgeAuthClient, KnowledgeTenantClient, KnowledgeAgentClient, AuthError } from '@native-knowledge/knowledge-sdk';
 import { ProfileStore } from './profile-store.js';
 import { login, logout, profileProvider, expectedSession } from './auth-commands.js';
-import { commands, retired, help } from './commands.js';
+import { commands, retired, localCommands, commandHelp } from './commands.js';
 import { parse, one, integer, smallFile, argumentsFor } from './input.js';
 import { download } from './download.js';
 let context, human = false;
 async function main() {
     const { command, flags: f } = parse(process.argv.slice(2));
     human = f.has('human');
-    if (!command || command === 'help' || f.has('help'))
-        return help;
+    if (!command || command === 'help' || command.startsWith('help ') || f.has('help')) {
+        const topic = command === 'help' ? '' : command.startsWith('help ') ? command.slice(5) : command;
+        const value = commandHelp(topic);
+        if (!value)
+            throw new AuthError('CLI_TOOL_UNSUPPORTED');
+        return value;
+    }
     if (retired.has(command))
         throw new AuthError('CLI_LOCAL_ACCESS_REMOVED');
-    if (!Object.hasOwn(commands, command) && !['auth login', 'auth status', 'auth whoami', 'auth logout', 'profile list', 'profile use', 'profile remove', 'discover', 'tool list', 'tool describe', 'tool call', 'resource file', 'agent find', 'agent tool', 'agent call', 'agent task', 'agent input'].includes(command))
+    if (!Object.hasOwn(commands, command) && !localCommands.includes(command))
         throw new AuthError('CLI_TOOL_UNSUPPORTED');
     const store = new ProfileStore(path.resolve(one(f, 'config-dir') ?? path.join(process.env.XDG_CONFIG_HOME ?? path.join(homedir(), '.config'), 'native-knowledge'))), profileName = one(f, 'profile');
     if (command === 'profile list') {

package/dist/commands.js

@@ -4,6 +4,8 @@ export const commands = {
     'source list': 'tenant_source_list', 'source get': 'tenant_source_get', 'source define': 'tenant_source_define', 'source configure': 'tenant_source_configure',
     'collection request': 'tenant_collection_request', 'collection status': 'tenant_collection_status',
     'project list': 'tenant_project_list', 'project get': 'tenant_project_get', 'project materials': 'tenant_project_materials', 'project scope-set': 'tenant_project_scope_set', 'project lifecycle-set': 'tenant_project_lifecycle_set',
+    'event materials': 'tenant_event_materials',
+    'event connection': 'tenant_event_exchange_get', 'event status': 'tenant_event_connection_status', 'event connections': 'tenant_event_exchange_list', 'event configure': 'tenant_event_exchange_configure', 'event receipt': 'tenant_event_exchange_receipt', 'event deliveries': 'tenant_event_outbox_list', 'event recover': 'tenant_event_outbox_recover', 'event recovery-receipt': 'tenant_event_outbox_recovery_receipt', 'event gap-recover': 'tenant_event_gap_recover', 'event gap-receipt': 'tenant_event_gap_recovery_receipt', 'event baseline': 'tenant_event_gap_baseline_read',
     'runtime status': 'tenant_runtime_status', 'work queue': 'tenant_work_queue',
     'artifact draft': 'tenant_artifact_draft', 'artifact review': 'tenant_knowledge_review', 'artifact promote': 'tenant_artifact_promote', 'knowledge compose': 'tenant_knowledge_compose', 'insight compose': 'tenant_knowledge_compose', 'knowledge read': 'tenant_knowledge_read',
     'material share': 'tenant_material_share', 'material revoke': 'tenant_material_revoke', 'material routes': 'tenant_material_routes', 'snapshot declare': 'tenant_snapshot_declare', 'snapshot status': 'tenant_snapshot_status',
@@ -15,3 +17,27 @@ for (const op of ['preview', 'submit', 'status', 'results', 'cycles', 'read', 'p
 export const localFlags = new Set(['data-root', 'identity-database', 'node-id', 'tenant', 'user', 'agent', 'cursor-secret-env', 'file-roots', 'browser-fallback', 'projection-mode', 'consumer-profile-file']);
 export const retired = new Set(['project-intent put', 'project-intent get', 'source put', 'source preview', 'source add-url', 'source add-file', 'source add-executor', 'source reproject', 'source drift', 'source rebind', 'source due', 'batch create', 'batch create-due', 'batch get', 'batch collector-view', 'batch run', 'batch run-get', 'material page', 'material describe', 'material scope get', 'material scope set', 'material status', 'material publish', 'material location select', 'material put', 'artifact create', 'artifact get', 'artifact list', 'artifact index', 'artifact support', 'reference gap-audit', 'delivery content-factory project', 'delivery content-factory stage', 'delivery content-factory outbox-list', 'delivery content-factory record']);
 export const help = { name: 'native-knowledge', alias: 'knowledge-v2', schemaVersion: 1, transport: 'REMOTE_OAUTH_TENANT', commands: ['auth login|status|whoami|logout', 'profile list|use|remove', 'discover', 'tool list|describe|call', 'resource file', 'agent find', 'agent tool', 'agent call', 'agent task', 'agent input', ...Object.keys(commands)], input: '--input-file <JSON> | --input-json <JSON>; --content-file <file> for submit/draft', connection: '--server <API-root> --profile <name> --token-file <file> --tenant-id <expected-Tenant>', login: 'auth login --server <API-root> --client-id <registered-native-client> [--scope <scope> ...] [--authority-version 1|2] [--no-browser] [--callback-port <port>]', rules: ['Tenant identity comes from the server session. Project is an explicit narrowing.', 'No database, local collection or Host maintenance access.', 'Noninteractive business calls never open a browser. stdout is one JSON result.'] };
+/** Local command names also drive offline help; live schemas remain server-owned. */
+export const localCommands = [
+    'auth login', 'auth status', 'auth whoami', 'auth logout', 'profile list', 'profile use', 'profile remove',
+    'discover', 'tool list', 'tool describe', 'tool call', 'resource file',
+    'agent find', 'agent tool', 'agent call', 'agent task', 'agent input',
+];
+export const commandNames = [...localCommands, ...Object.keys(commands)];
+export function commandHelp(topic = '') {
+    const groups = [...new Set(commandNames.filter(name => name.includes(' ')).map(name => name.split(' ')[0]))];
+    if (!topic)
+        return { ...help, groups, help: 'native-knowledge help [<group> [<command>]]' };
+    const selected = commandNames.filter(name => name === topic || name.startsWith(topic + ' '));
+    if (!selected.length)
+        return undefined;
+    return {
+        name: help.name, alias: help.alias, schemaVersion: help.schemaVersion, transport: help.transport,
+        topic, commands: selected, input: help.input, connection: help.connection, rules: help.rules,
+        ...(topic === 'auth' || topic === 'auth login' ? { login: help.login } : {}),
+        ...(commands[topic] && topic !== 'agent status' ? {
+            tool: commands[topic], schema: `native-knowledge tool describe --tool ${commands[topic]}`,
+        } : {}),
+        help: 'Use a command with --help; authenticated tool describe returns the current schema and availability.',
+    };
+}

package/dist/errors.js

@@ -1,7 +1,7 @@
-import { AuthError, TenantManagementSdkError, ResourceSdkError, TenantOperationUnknownError } from '@native-knowledge/knowledge-sdk';
+import { AuthError, TenantManagementSdkError, ResourceSdkError, TenantOperationUnknownError, TenantEventOperationUnknownError } from '@native-knowledge/knowledge-sdk';
 import { agentEntryFailure } from './agent-entry-cli.js';
 /** A CLI failure never authorizes replay; retained phases remain partial completion. */
 export function cliFailure(e) {
     const status = e instanceof AuthError || e instanceof TenantManagementSdkError || e instanceof ResourceSdkError ? e.status : 0, raw = e instanceof AuthError ? e.code : e instanceof TenantManagementSdkError || e instanceof ResourceSdkError ? e.code : e instanceof Error && e.name === 'ZodError' ? 'CLI_INPUT_INVALID' : e instanceof Error && /^[A-Z][A-Z0-9_]{1,100}$/.test(e.message) ? e.message : 'CLI_OPERATION_FAILED', code = /^[A-Z][A-Z0-9_]{1,100}$/.test(raw) ? raw : 'CLI_OPERATION_FAILED', exit = (e instanceof TenantManagementSdkError || e instanceof TenantOperationUnknownError) && e.completedPhase ? 7 : code.includes('UNKNOWN') || code.includes('INCOMPLETE') ? 7 : status === 403 || code.includes('FORBIDDEN') ? 4 : status === 409 || code.includes('CONFLICT') ? 5 : status >= 500 || code.includes('TRANSPORT') ? 6 : code.includes('AUTH_') ? 3 : 2;
-    return { exit, error: { code, status, ...(agentEntryFailure(e) ?? {}), retryable: false, nextActions: code === 'AUTH_LOGOUT_REQUIRED' ? [{ command: 'native-knowledge auth logout', automatic: false }] : code === 'AUTH_CREDENTIAL_SOURCE_CONFLICT' ? [{ command: 'native-knowledge help', automatic: false }] : e instanceof TenantOperationUnknownError && e.requestId ? [{ tool: 'tenant_operation_status', arguments: { requestId: e.requestId }, automatic: false, requiredScopes: ['knowledge.workflow.read'] }] : exit === 3 ? [{ command: 'native-knowledge auth login', automatic: false }] : code === 'CLI_LOCAL_ACCESS_REMOVED' ? [{ command: 'native-knowledge help', automatic: false, documentation: 'docs/operations/tenant-cli-migration.md' }] : [], ...((e instanceof TenantManagementSdkError || e instanceof TenantOperationUnknownError) ? { completedPhase: e.completedPhase, ref: e.ref } : {}), ...(e instanceof TenantOperationUnknownError ? { requestId: e.requestId } : {}) } };
+    return { exit, error: { code, status, ...(agentEntryFailure(e) ?? {}), retryable: false, nextActions: code === 'AUTH_LOGOUT_REQUIRED' ? [{ command: 'native-knowledge auth logout', automatic: false }] : code === 'AUTH_CREDENTIAL_SOURCE_CONFLICT' ? [{ command: 'native-knowledge help', automatic: false }] : e instanceof TenantEventOperationUnknownError ? [{ tool: e.receiptTool, arguments: { requestId: e.requestId }, automatic: false, requiredScopes: ['knowledge.material.route'] }] : e instanceof TenantOperationUnknownError && e.requestId ? [{ tool: 'tenant_operation_status', arguments: { requestId: e.requestId }, automatic: false, requiredScopes: ['knowledge.workflow.read'] }] : exit === 3 ? [{ command: 'native-knowledge auth login', automatic: false }] : code === 'CLI_LOCAL_ACCESS_REMOVED' ? [{ command: 'native-knowledge help', automatic: false, documentation: 'docs/operations/tenant-cli-migration.md' }] : [], ...((e instanceof TenantManagementSdkError || e instanceof TenantOperationUnknownError) ? { completedPhase: e.completedPhase, ref: e.ref } : {}), ...((e instanceof TenantOperationUnknownError || e instanceof TenantEventOperationUnknownError) ? { requestId: e.requestId } : {}) } };
 }

package/dist/internal/contracts/index.js

@@ -52,3 +52,4 @@ export * from './tenant-web-content-plan.js';
 export * from './tenant-web-content-result.js';
 export * from './tenant-web-content.js';
 export * from './tenant-web-workflow.js';
+export * from './resource-transfer.js';

package/dist/internal/contracts/resource-transfer.js

@@ -0,0 +1,11 @@
+/** Explicit transfer binding leaves historical Provider16 JSON and clients unchanged. */
+import { z } from 'zod';
+import { sha256Schema } from './common.js';
+import { materialContextSchema } from './material-context.js';
+import { materialAuthorityPolicySchema } from './resource-scope.js';
+import { resourceEnvelopeSchema } from './tenant-resource-api.js';
+export const resourceTransferRequestHeader = 'x-knowledge-resource-transfer';
+export const resourceTransferFeature = 'context-v1';
+export const resourceTransferResponseHeader = 'x-knowledge-resource-context';
+export const resourceTransferBindingSchema = z.object({ schemaVersion: z.literal(1), context: materialContextSchema, policy: materialAuthorityPolicySchema, refHash: sha256Schema }).strict().superRefine((value, ctx) => { if (!resourceEnvelopeSchema.safeParse({ schemaVersion: 2, context: value.context, policy: value.policy, data: null }).success)
+    ctx.addIssue({ code: 'custom', message: 'Transfer context and policy mismatch' }); });

package/dist/internal/contracts/runtime-compatibility.js

@@ -6,8 +6,8 @@ export const tenantCoreReadCapabilities = [
 ];
 export const tenantCoreWriteCapabilities = ['TENANT_COLLECTION_V2', 'TENANT_ADMISSION_STOP_V1', 'TENANT_ADMISSION_V2'];
 export function runtimeCompatibility(component) {
-    return { schemaVersion: 1, component, identityReadMinimum: 11, identityReadMaximum: 21,
-        capabilities: component === 'core' ? [...tenantCoreReadCapabilities, ...tenantCoreWriteCapabilities, 'TENANT_NATIVE_CLIENT_AUTH_V1'] : [...tenantCoreReadCapabilities, 'TENANT_NATIVE_CLIENT_AUTH_V1'],
+    return { schemaVersion: 1, component, identityReadMinimum: 11, identityReadMaximum: 24,
+        capabilities: component === 'core' ? [...tenantCoreReadCapabilities, ...tenantCoreWriteCapabilities, 'TENANT_NATIVE_CLIENT_AUTH_V1', 'TENANT_COMPACT_LINEAGE_V1', 'TENANT_AUTHORITY_SET_V1', 'TENANT_MATERIAL_HISTORY_V1'] : [...tenantCoreReadCapabilities, 'TENANT_NATIVE_CLIENT_AUTH_V1', 'TENANT_COMPACT_LINEAGE_V1', 'TENANT_AUTHORITY_SET_V1', 'TENANT_MATERIAL_HISTORY_V1'],
         tenantProviders: component === 'core' ? [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26] : [], requiredCoreProviders: component === 'admin-web' ? [20] : [],
         budgetReadVersions: component === 'core' ? [2] : [], budgetMigrationVersions: component === 'core' ? [1] : [] };
 }
@@ -16,7 +16,7 @@ export function assertRuntimeFormatCompatibility(raw, facts, component, mode) {
     const fail = (code) => { throw new Error('RUNTIME_COMPATIBILITY_' + code); };
     if (!['core', 'admin-web'].includes(component) || !['INSTALL', 'START', 'ROLLBACK', 'RECOVERY'].includes(mode))
         fail('CONTEXT_INVALID');
-    if (!Number.isSafeInteger(facts.identityVersion) || facts.identityVersion < 11 || facts.identityVersion > 21)
+    if (!Number.isSafeInteger(facts.identityVersion) || facts.identityVersion < 11 || facts.identityVersion > 24)
         fail('IDENTITY_UNSUPPORTED');
     if (facts.budgetVersion !== null && ![1, 2].includes(facts.budgetVersion))
         fail('BUDGET_UNSUPPORTED');
@@ -30,7 +30,7 @@ export function assertRuntimeFormatCompatibility(raw, facts, component, mode) {
     const value = raw, expected = runtimeCompatibility(component), keys = Object.keys(expected);
     if (Object.keys(value).length !== keys.length || Object.keys(value).some(key => !keys.includes(key)) || value.schemaVersion !== 1 || value.component !== component)
         fail('DECLARATION_INVALID');
-    if (!Number.isSafeInteger(value.identityReadMinimum) || !Number.isSafeInteger(value.identityReadMaximum) || value.identityReadMinimum < 11 || value.identityReadMaximum > 21 || value.identityReadMinimum > value.identityReadMaximum)
+    if (!Number.isSafeInteger(value.identityReadMinimum) || !Number.isSafeInteger(value.identityReadMaximum) || value.identityReadMinimum < 11 || value.identityReadMaximum > 24 || value.identityReadMinimum > value.identityReadMaximum)
         fail('DECLARATION_INVALID');
     for (const key of ['capabilities', 'tenantProviders', 'requiredCoreProviders', 'budgetReadVersions', 'budgetMigrationVersions']) {
         const list = value[key], allowed = expected[key];
@@ -39,7 +39,7 @@ export function assertRuntimeFormatCompatibility(raw, facts, component, mode) {
     }
     if (facts.identityVersion < value.identityReadMinimum || facts.identityVersion > value.identityReadMaximum)
         fail('IDENTITY_UNSUPPORTED');
-    if (facts.identityVersion >= 12 && expected.capabilities.some(cap => (facts.identityVersion >= 21 || cap !== 'TENANT_NATIVE_CLIENT_AUTH_V1') && !value.capabilities.includes(cap)))
+    if (facts.identityVersion >= 12 && expected.capabilities.some(cap => (facts.identityVersion >= 21 || cap !== 'TENANT_NATIVE_CLIENT_AUTH_V1') && (facts.identityVersion >= 22 || cap !== 'TENANT_COMPACT_LINEAGE_V1') && (facts.identityVersion >= 23 || cap !== 'TENANT_AUTHORITY_SET_V1') && (facts.identityVersion >= 24 || cap !== 'TENANT_MATERIAL_HISTORY_V1') && !value.capabilities.includes(cap)))
         fail('CAPABILITY_REQUIRED');
     // New Provider21/22 are advertised, but historical Identity >=12 does not imply the new opt-in writer.
     if (facts.identityVersion >= 12 && ['tenantProviders', 'requiredCoreProviders'].some(key => (key === 'tenantProviders' && component === 'core' ? [16, 17, 18, 19, 20] : expected[key]).some(version => !value[key].includes(version))))

package/dist/internal/serving-contracts/index.js

@@ -23,3 +23,4 @@ export * from './agent-catalog.js';
 export * from './body-search.js';
 export * from './agent-guidance-shapes.js';
 export * from './agent-input-hints.js';
+export * from './tenant-events.js';

package/dist/internal/serving-contracts/mcp.js

@@ -18,10 +18,7 @@ export const knowledgeMcpProviderContractSchema = z.object({
 /** 版本化元数据只声明实际启用的协议；保留严格 v1，避免旧消费者误认新增生命周期。 */
 const providerV2BaseSchema = knowledgeMcpProviderContractSchema.omit({ schemaVersion: true, protocolVersion: true }).extend({
     schemaVersion: z.literal(2), defaultProtocolVersion: z.literal(knowledgeMcpProtocolVersion),
-    protocols: z.array(z.discriminatedUnion('version', [
-        z.object({ version: z.literal('2026-07-28'), lifecycle: z.literal('STATELESS_DISCOVERY'), transport: z.literal('STREAMABLE_HTTP') }).strict(),
-        z.object({ version: z.literal('2025-06-18'), lifecycle: z.literal('INITIALIZE'), transport: z.literal('STREAMABLE_HTTP') }).strict(),
-    ])).min(1).max(2),
+    protocols: z.array(z.object({ version: z.literal('2026-07-28'), lifecycle: z.literal('STATELESS_DISCOVERY'), transport: z.literal('STREAMABLE_HTTP') }).strict()).length(1),
 }).strict();
 export const knowledgeMcpProviderContractV2Schema = providerV2BaseSchema.superRefine((value, ctx) => {
     const versions = value.protocols.map(p => p.version);

package/dist/internal/serving-contracts/tenant-events.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+// Data-only Native HTTP projection. EventSDK remains the server-side protocol validator.
+const atom = (max = 256) => z.string().min(1).max(max).regex(/^[^\u0000-\u0020\u007f]+$/);
+const uri = z.string().url().max(2048), positive = z.number().int().min(1).max(2147483647), generation = z.number().int().min(0).max(2147483647);
+export const tenantMaterialEventType = 'io.nativeknowledge.tenant-material.changed.v1';
+export const tenantEventSourceSchema = z.object({ source: uri, serviceRef: atom(), tenantRef: atom(), issuer: uri, subject: atom() }).strict();
+export const tenantEventRegistrationSchema = z.object({ schemaVersion: z.literal(1), requestId: atom(), expectedRevision: positive.nullable(), source: tenantEventSourceSchema, target: z.object({ serviceRef: atom(), tenantRef: atom() }).strict(), grant: z.object({ grantRef: atom(), version: positive, eventType: atom().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*\.v[1-9][0-9]*$/), consumerRef: atom() }).strict(), status: z.enum(['ACTIVE', 'REVOKED']) }).strict();
+export const tenantEventOutboxRecoverySchema = z.object({ schemaVersion: z.literal(1), requestId: atom(), source: uri, id: atom(), deliveryid: z.string().regex(/^[a-f0-9]{64}$/), expectedGeneration: generation }).strict();
+export const tenantEventGapRecoverySchema = z.object({ schemaVersion: z.literal(1), requestId: atom(), connectionRef: atom(128), expectedCursor: atom(), expectedOldestAvailableCursor: atom() }).strict();
+const directoryPage = z.object({ connectionRef: atom(128), after: z.string().max(2048).optional(), limit: z.number().int().min(1).max(100).optional() }).strict();
+const receiptInput = z.object({ requestId: atom() }).strict();
+export const tenantEventToolSchemas = {
+    tenant_event_materials: directoryPage,
+    tenant_event_connection_status: z.object({}).strict(),
+    tenant_event_exchange_get: z.object({ connectionRef: atom(128) }).strict(),
+    tenant_event_exchange_list: z.object({ after: z.string().max(256).optional(), limit: z.number().int().min(1).max(100).optional() }).strict(),
+    tenant_event_exchange_configure: tenantEventRegistrationSchema,
+    tenant_event_exchange_receipt: receiptInput,
+    tenant_event_outbox_list: z.object({ after: z.number().int().nonnegative().optional(), limit: z.number().int().min(1).max(100).optional() }).strict(),
+    tenant_event_outbox_recover: tenantEventOutboxRecoverySchema,
+    tenant_event_outbox_recovery_receipt: receiptInput,
+    tenant_event_gap_recover: tenantEventGapRecoverySchema,
+    tenant_event_gap_recovery_receipt: receiptInput,
+    tenant_event_gap_baseline_read: z.object({ baselineRef: uri }).strict(),
+};
+export const tenantEventReadTools = new Set(['tenant_event_materials', 'tenant_event_connection_status', 'tenant_event_exchange_get', 'tenant_event_exchange_list', 'tenant_event_exchange_receipt', 'tenant_event_outbox_list', 'tenant_event_outbox_recovery_receipt', 'tenant_event_gap_recovery_receipt', 'tenant_event_gap_baseline_read']);
+export const tenantEventWorkerSchema = z.object({ schemaVersion: z.literal(1), status: z.enum(['DISABLED', 'CONNECTED', 'RECONNECTING', 'STOPPED']), connected: z.boolean(), at: z.string().datetime(), revision: z.string().optional(), stale: z.boolean() }).strict();
+const route = z.object({ connectionRef: atom(128), tenantId: atom(), revision: positive, binding: tenantEventRegistrationSchema }).strict();
+const exchangeResult = z.object({ schemaVersion: z.literal(1), connectionRef: atom(128), revision: positive, status: z.enum(['ACTIVE', 'REVOKED']), grantRef: atom(), grantVersion: positive }).strict();
+const baseline = z.object({ schemaVersion: z.literal(1), baselineRef: uri, source: uri, sourceTenant: atom(), targetService: atom(), targetTenant: atom(), connectionRef: atom(128), grantRef: atom(), grantVersion: positive, previousWatermark: atom(), retainedThrough: atom(), watermark: atom(), sourceRevision: atom(), createdAt: z.string().datetime(), readModel: z.literal('AUTHORITATIVE_ON_DEMAND'), directoryRef: uri }).strict();
+const outboxResult = z.object({ schemaVersion: z.literal(1), requestId: atom(), source: uri, id: atom(), deliveryid: z.string().regex(/^[a-f0-9]{64}$/), status: z.literal('REQUEUED'), generation: positive, previousOutcome: z.json().nullable(), attempt: z.number().int().nonnegative() }).strict();
+const gapResult = z.object({ schemaVersion: z.literal(1), requestId: atom(), status: z.literal('BASELINE_STAGED'), baseline, event: z.object({ source: uri, id: atom(), deliveryid: z.string().regex(/^[a-f0-9]{64}$/) }).strict(), checkpoint: z.object({ previous: atom(), current: atom() }).strict() }).strict();
+const receipt = (result) => z.object({ schemaVersion: z.literal(1), requestId: atom(), result: result.nullable() }).strict();
+export const tenantEventResultSchemas = {
+    tenant_event_materials: z.object({ schemaVersion: z.literal(1), connectionRef: atom(128), resourceAccess: z.object({ providerPath: z.literal('/v16/provider'), tools: z.tuple([z.literal('knowledge_resource_describe'), z.literal('knowledge_resource_read')]) }).strict(), items: z.array(z.object({ ref: uri, title: z.string().max(4096) }).strict()).max(100), nextAfter: uri.nullable() }).strict(),
+    tenant_event_connection_status: z.object({ schemaVersion: z.literal(1), configuration: z.enum(['DISABLED', 'PROFILE_VALID', 'INVALID']), mode: z.enum(['DISABLED', 'SHADOW', 'ACTIVE']).nullable(), source: tenantEventSourceSchema.nullable(), relay: z.enum(['NOT_CONFIGURED', 'AVAILABLE', 'UNAVAILABLE']), worker: tenantEventWorkerSchema.nullable(), eventType: z.literal(tenantMaterialEventType), counterpartAcceptance: z.literal('NOT_OBSERVED') }).strict(),
+    tenant_event_exchange_get: z.object({ schemaVersion: z.literal(1), item: route.nullable() }).strict(),
+    tenant_event_exchange_list: z.object({ schemaVersion: z.literal(1), items: z.array(route).max(100), nextAfter: z.string().max(256).nullable() }).strict(),
+    tenant_event_exchange_configure: exchangeResult,
+    tenant_event_exchange_receipt: receipt(exchangeResult),
+    tenant_event_outbox_list: z.object({ schemaVersion: z.literal(1), items: z.array(z.object({ source: uri, id: atom(), deliveryid: z.string().regex(/^[a-f0-9]{64}$/), status: z.enum(['PENDING', 'UNKNOWN', 'PUBLISHED', 'HOLD']), generation, attempt: z.number().int().nonnegative(), nextAttemptAt: z.number().int().nonnegative(), reasonCode: z.string().max(256).nullable() }).strict()).max(100), nextAfter: z.number().int().nonnegative().nullable(), gaps: z.array(z.object({ route_key: atom(), connectionRef: atom(128), cursor: atom(), gap_oldest: atom() }).strict()).max(100), worker: tenantEventWorkerSchema.nullable() }).strict(),
+    tenant_event_outbox_recover: outboxResult,
+    tenant_event_outbox_recovery_receipt: receipt(outboxResult),
+    tenant_event_gap_recover: gapResult,
+    tenant_event_gap_recovery_receipt: receipt(gapResult),
+    tenant_event_gap_baseline_read: z.object({ schemaVersion: z.literal(1), baseline: baseline.nullable() }).strict(),
+};
+export function tenantEventEnvelopeSchema(tool) { return z.object({ schemaVersion: z.literal(27), tenantId: atom(), tool: z.literal(tool), data: tenantEventResultSchemas[tool] }).strict(); }
+export const tenantEventErrorCodes = ['EVENTSDK_OPERATION_RESULT_UNKNOWN', 'TENANT_MANAGEMENT_AUTHORITY_CHANGED', 'TENANT_MANAGEMENT_FORBIDDEN', 'EVENTSDK_INVALID_INPUT', 'EVENTSDK_SOURCE_NOT_CONFIGURED', 'EVENTSDK_RELAY_NOT_CONFIGURED', 'EVENTSDK_EXCHANGE_UNAVAILABLE', 'EVENTSDK_REQUEST_ID_CONFLICT', 'EVENTSDK_EXCHANGE_REVISION_CONFLICT', 'EVENTSDK_GRANT_VERSION_CONFLICT', 'EVENTSDK_GAP_CONFLICT', 'RECOVERY_REQUIRED', 'STALE_LEASE', 'EVENTSDK_GAP_SOURCE_CHANGED', 'TENANT_MANAGEMENT_INPUT_BUDGET'];
+export const tenantEventErrorSchema = z.object({ errorCode: z.enum(tenantEventErrorCodes) }).strict();
+export const tenantEventInputJsonSchemas = Object.fromEntries(Object.entries(tenantEventToolSchemas).map(([name, schema]) => [name, z.toJSONSchema(schema, { target: 'draft-07' })]));
+export const tenantEventOutputJsonSchemas = Object.fromEntries(Object.keys(tenantEventToolSchemas).map(name => [name, z.toJSONSchema(tenantEventEnvelopeSchema(name), { target: 'draft-07' })]));
+export const tenantEventProviderSchema = z.object({ schemaVersion: z.literal(27), authorityVersion: z.literal(2), requiredScope: z.literal('knowledge.material.route'), readScope: z.literal('knowledge.material.read'), resource: uri, callEndpoint: uri, mcpEndpoint: uri, tools: z.array(z.object({ name: z.enum(Object.keys(tenantEventToolSchemas)), description: z.string(), inputSchema: z.json(), outputSchema: z.json(), annotations: z.object({ readOnlyHint: z.boolean(), destructiveHint: z.boolean(), idempotentHint: z.boolean(), openWorldHint: z.boolean() }).strict(), _meta: z.object({ 'native-knowledge/requiredScope': z.enum(['knowledge.material.route', 'knowledge.material.read']) }).strict() }).strict()).max(32) }).strict();
+/** Native event-link/1 handoff, separate from EventSDK transport contracts. */
+export const tenantEventLinkProposalSchema = z.object({ schemaVersion: z.literal(1), requestId: atom(), source: tenantEventSourceSchema, target: tenantEventRegistrationSchema.shape.target, grant: tenantEventRegistrationSchema.shape.grant, connectionRef: atom(128), targetDisplayName: z.string().min(1).max(160), approvalRef: atom(), expiresAt: z.string().datetime() }).strict();
+export const tenantEventLinkCatalogSchema = z.object({ schemaVersion: z.literal(1), applications: z.array(z.object({ id: atom(64), name: z.string().min(1).max(80), serviceRef: atom(), origin: z.string().url().max(512), clientId: atom(128), consumerRef: atom().optional() }).strict()).max(8) }).strict();
+export function tenantEventToolScope(name) { return name === 'tenant_event_materials' ? 'knowledge.material.read' : 'knowledge.material.route'; }

package/dist/internal/serving-contracts/tenant-management.js

@@ -75,7 +75,7 @@ export const tenantManagementErrorSchema = z.object({ errorCode: tenantManagemen
 export function tenantManagementEnvelopeSchema(tool) { return z.object({ schemaVersion: z.literal(2), tenantId: materialTenantIdSchema, tool: z.literal(tool), data: tenantManagementDataSchemas[tool] }).strict(); }
 export const tenantManagementInputJsonSchemas = Object.fromEntries(Object.entries(tenantManagementToolSchemas).map(([name, schema]) => [name, z.toJSONSchema(schema, { target: 'draft-07' })]));
 export const tenantManagementOutputJsonSchemas = Object.fromEntries(Object.keys(tenantManagementToolSchemas).map(name => [name, { type: 'object', oneOf: [z.toJSONSchema(tenantManagementEnvelopeSchema(name), { target: 'draft-07' }), z.toJSONSchema(tenantManagementErrorSchema, { target: 'draft-07' })] }]));
-export const tenantManagementProviderBaseSchema = z.object({ schemaVersion: z.literal(17), provider: z.literal('knowledge-v2'), codeRevision: z.string().min(1).max(128), authorityVersion: z.literal(2), context: z.literal('TENANT_EXPLICIT_MANAGEMENT_V1'), managementConfigured: z.boolean(), resource: stableUriSchema, issuer: stableUriSchema, authorizationEndpoint: stableUriSchema, tokenEndpoint: stableUriSchema, revocationEndpoint: stableUriSchema, mcpEndpoint: stableUriSchema, callEndpoint: stableUriSchema, contentEndpoint: stableUriSchema, contentContextHeader: z.literal('x-knowledge-tenant-id'), legacyProviderEndpoint: stableUriSchema, protocols: z.array(z.enum(['2026-07-28', '2025-06-18'])).min(1).max(2), tools: z.array(z.string()).length(Object.keys(tenantManagementToolSchemas).length), requestMaxBytes: z.literal(131072), resultMaxBytes: z.literal(524288), submissionMaxBytes: z.literal(65536), inlineContentMaxBytes: z.literal(32768), contentReadMaxBytes: z.literal(16777216), collectionMode: z.literal('MANUAL_ONLY_OAUTH'), capabilities: z.tuple([z.literal('TENANT_MANAGEMENT_V1'), z.literal('TENANT_WORKFLOW_V1'), z.literal('TENANT_CURRENTNESS_V2'), z.literal('TENANT_SOURCE_V1')]) }).strict();
+export const tenantManagementProviderBaseSchema = z.object({ schemaVersion: z.literal(17), provider: z.literal('knowledge-v2'), codeRevision: z.string().min(1).max(128), authorityVersion: z.literal(2), context: z.literal('TENANT_EXPLICIT_MANAGEMENT_V1'), managementConfigured: z.boolean(), resource: stableUriSchema, issuer: stableUriSchema, authorizationEndpoint: stableUriSchema, tokenEndpoint: stableUriSchema, revocationEndpoint: stableUriSchema, mcpEndpoint: stableUriSchema, callEndpoint: stableUriSchema, contentEndpoint: stableUriSchema, contentContextHeader: z.literal('x-knowledge-tenant-id'), legacyProviderEndpoint: stableUriSchema, protocols: z.array(z.literal('2026-07-28')).length(1), tools: z.array(z.string()).length(Object.keys(tenantManagementToolSchemas).length), requestMaxBytes: z.literal(131072), resultMaxBytes: z.literal(524288), submissionMaxBytes: z.literal(65536), inlineContentMaxBytes: z.literal(32768), contentReadMaxBytes: z.literal(16777216), collectionMode: z.literal('MANUAL_ONLY_OAUTH'), capabilities: z.tuple([z.literal('TENANT_MANAGEMENT_V1'), z.literal('TENANT_WORKFLOW_V1'), z.literal('TENANT_CURRENTNESS_V2'), z.literal('TENANT_SOURCE_V1')]) }).strict();
 export const tenantManagementProviderSchema = tenantManagementProviderBaseSchema.superRefine((v, ctx) => { if (new Set(v.tools).size !== Object.keys(tenantManagementToolSchemas).length || v.tools.some(name => !Object.hasOwn(tenantManagementToolSchemas, name)))
     ctx.addIssue({ code: 'custom', message: 'Provider tools must match the exact native tool contract' }); });
 /** 诊断 ref 只允许当前访问 Tenant 的 canonical 原生身份；不接受 URL/本机路径。 */

package/package.json

@@ -1,20 +1,14 @@
 {
   "name": "@native-knowledge/cli",
-  "version": "0.1.0-rc.2",
+  "version": "0.1.0-rc.4",
   "private": false,
   "type": "module",
-  "description": "Remote Tenant CLI with OAuth and Agent-native discovery",
   "engines": {
     "node": ">=24"
   },
   "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/SENLIN746/native-knowledge.git"
-  },
   "files": [
     "dist",
-    "README.md",
     "LICENSE",
     "NOTICE"
   ],
@@ -23,7 +17,7 @@
     "knowledge-v2": "./dist/cli.js"
   },
   "dependencies": {
-    "@native-knowledge/knowledge-sdk": "0.1.0-rc.2",
+    "@native-knowledge/knowledge-sdk": "0.1.0-rc.4",
     "zod": "^4.6.7"
   }
-}
+}

package/README.md

@@ -1,35 +0,0 @@
-# native-knowledge CLI
-
-Remote Tenant and Agent-native client. Requires Node.js 24 or newer.
-
-```sh
-pnpm add --global @native-knowledge/cli@next
-native-knowledge help
-native-knowledge discover --server https://knowledge.example.com
-native-knowledge auth login --server https://knowledge.example.com
-native-knowledge auth whoami
-native-knowledge tool list
-native-knowledge auth logout
-```
-
-`knowledge-v2` is a compatible alias for the same remote client. stdout is one
-JSON result; `--human` formats that result. `help` describes supported commands,
-inputs and connection options. Agent discovery, typed tool calls and resource
-downloads use the same server authorization as the SDK.
-
-The service must admit the native public client and requested scopes. Browser
-consent and PKCE bind the actual loopback callback. Tenant management additionally
-requires current membership, client/audience delegation and runtime bindings;
-successful login alone does not grant management authority.
-
-Login creates private local profile and credential files. Do not copy credentials
-into scripts, source control or shared configuration. Noninteractive business
-commands do not open a browser or silently log in. Unknown mutation outcomes
-require a read-only status check; do not blindly replay them.
-
-The CLI does not open a business database, read local CAS, run collectors, use
-SSH or expose Host maintenance. Retired local database flags and commands fail
-before local business access. Install does not start services or collection.
-
-Pin an exact qualified version for repeatable installs. Prereleases use `next`.
-License: Apache-2.0. Historical MIT notices are retained in NOTICE.