@peers-app/peers-sdk 0.21.7 → 0.23.0

package/dist/data/workflow-logs.d.ts

@@ -29,8 +29,8 @@ export declare const workflowLogSchema: z.ZodObject<{
     resultObject: z.ZodOptional<z.ZodUnion<[z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>, z.ZodArray<z.ZodAny, "many">]>>;
     isError: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    workflowLogId: string;
     workflowRunId: string;
+    workflowLogId: string;
     contextId: string;
     logDT: Date;
     logText: string;
@@ -47,13 +47,13 @@ export declare const workflowLogSchema: z.ZodObject<{
     resultObject?: any[] | z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
     isError?: boolean | undefined;
 }, {
-    workflowLogId: string;
     workflowRunId: string;
+    workflowLogId: string;
     contextId: string;
     logText: string;
     toolId?: string | undefined;
-    logDT?: Date | undefined;
     result?: string | undefined;
+    logDT?: Date | undefined;
     instruction?: {
         markdown?: string | undefined;
         onError?: string | undefined;
@@ -67,8 +67,8 @@ export declare const workflowLogSchema: z.ZodObject<{
 }>;
 export type IWorkflowLog = z.infer<typeof workflowLogSchema>;
 export declare function WorkflowLogs(dataContext?: DataContext): import("..").Table<{
-    workflowLogId: string;
     workflowRunId: string;
+    workflowLogId: string;
     contextId: string;
     logDT: Date;
     logText: string;
@@ -86,8 +86,8 @@ export declare function WorkflowLogs(dataContext?: DataContext): import("..").Ta
     isError?: boolean | undefined;
 }>;
 export declare const getLogger: (workflowRunId: string, contextId: string) => (logData: string | Omit<Partial<IWorkflowLog>, "workflowRunId" | "workflowLogId">) => Promise<{
-    workflowLogId: string;
     workflowRunId: string;
+    workflowLogId: string;
     contextId: string;
     logDT: Date;
     logText: string;

package/dist/data/workflow-runs.d.ts

@@ -33,6 +33,7 @@ export declare const workflowRunSchema: z.ZodObject<{
     defaultAssistantId: z.ZodEffects<z.ZodString, string, string>;
 }, "strip", z.ZodTypeAny, {
     createdAt: Date;
+    workflowRunId: string;
     defaultAssistantId: string;
     instructions: {
         markdown?: string | undefined;
@@ -40,7 +41,6 @@ export declare const workflowRunSchema: z.ZodObject<{
         directCallToolId?: string | undefined;
         subWorkflowId?: string | undefined;
     }[];
-    workflowRunId: string;
     parentMessageId: string;
     currentInstructionIndex: number;
     instructionResults: any[];
@@ -54,8 +54,8 @@ export declare const workflowRunSchema: z.ZodObject<{
     completedAt?: Date | undefined;
     parentWorkflowRunId?: string | undefined;
 }, {
-    defaultAssistantId: string;
     workflowRunId: string;
+    defaultAssistantId: string;
     parentMessageId: string;
     createdAt?: Date | undefined;
     workflowId?: string | undefined;

package/dist/device-pairing/types.d.ts

@@ -715,14 +715,14 @@ export declare const pairingApprovalContentsSchema: z.ZodObject<{
     role: "source" | "destination";
     version: 1;
     expiresAt: number;
-    transcriptHash: string;
     approvalId: string;
+    transcriptHash: string;
 }, {
     role: "source" | "destination";
     version: 1;
     expiresAt: number;
-    transcriptHash: string;
     approvalId: string;
+    transcriptHash: string;
 }>;
 /** Contents of a signed pairing approval. */
 export type PairingApprovalContents = z.infer<typeof pairingApprovalContentsSchema>;
@@ -738,14 +738,14 @@ export declare const signedPairingApprovalSchema: z.ZodObject<{
         role: "source" | "destination";
         version: 1;
         expiresAt: number;
-        transcriptHash: string;
         approvalId: string;
+        transcriptHash: string;
     }, {
         role: "source" | "destination";
         version: 1;
         expiresAt: number;
-        transcriptHash: string;
         approvalId: string;
+        transcriptHash: string;
     }>;
     signature: z.ZodString;
     publicKey: z.ZodString;
@@ -756,8 +756,8 @@ export declare const signedPairingApprovalSchema: z.ZodObject<{
         role: "source" | "destination";
         version: 1;
         expiresAt: number;
-        transcriptHash: string;
         approvalId: string;
+        transcriptHash: string;
     };
 }, {
     publicKey: string;
@@ -766,8 +766,8 @@ export declare const signedPairingApprovalSchema: z.ZodObject<{
         role: "source" | "destination";
         version: 1;
         expiresAt: number;
-        transcriptHash: string;
         approvalId: string;
+        transcriptHash: string;
     };
 }>;
 /** Signed approval bound to one transcript and endpoint identity. */

package/dist/package-installer/package-creator.d.ts

@@ -12,11 +12,42 @@ export declare function nameToFolderSlug(name: string): string;
  * @returns The path to the cached template directory.
  */
 export declare function ensureTemplateCache(deps: IPackageInstallerDeps, templateRepo: string): Promise<string>;
+/**
+ * Resolve (or create) the Ed25519 publish public key for a package.
+ *
+ * Idempotent: never rotates an established key. Reuses `existingPublishPublicKey`
+ * when present, derives the public key from an existing secret pvar when possible,
+ * and only generates a new keypair when both are missing.
+ *
+ * @throws When a readable secret key does not match an established `publishPublicKey`.
+ */
+export declare function ensurePackageSigningKey(opts: {
+    personalContext?: DataContext;
+    packageId: string;
+    packageName: string;
+    existingPublishPublicKey?: string;
+}): Promise<string>;
+/**
+ * Import an existing on-disk Peers package directory into the current data context.
+ *
+ * Validates the manifest packageId, creates/updates the Packages record, persists
+ * `packageLocalPath_*`, provisions a signing key when missing, then installs the
+ * local dev bundles.
+ */
+export declare function importExistingPackage(dataContext: DataContext, deps: IPackageInstallerDeps, opts: {
+    location: string;
+    personalContext?: DataContext;
+    /** Display name fallback when the manifest name is a slug. */
+    displayName?: string;
+}): Promise<ICreatePackageResult>;
 /**
  * Create a new Peers package from the package template.
  *
  * Clones the template repo, patches IDs and metadata, runs npm install + build,
  * initializes a fresh git repo, then delegates to {@link installPackageFromBundles}
  * to register the dev bundle in the database.
+ *
+ * When `location` already exists and contains a valid Peers package manifest,
+ * imports that directory instead (see {@link importExistingPackage}).
  */
 export declare function createPackage(dataContext: DataContext, deps: IPackageInstallerDeps, opts: ICreatePackageOpts): Promise<ICreatePackageResult>;

package/dist/package-installer/package-creator.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nameToFolderSlug = nameToFolderSlug;
 exports.ensureTemplateCache = ensureTemplateCache;
+exports.ensurePackageSigningKey = ensurePackageSigningKey;
+exports.importExistingPackage = importExistingPackage;
 exports.createPackage = createPackage;
 const packages_1 = require("../data/packages");
 const persistent_vars_1 = require("../data/persistent-vars");
@@ -42,29 +44,148 @@ async function ensureTemplateCache(deps, templateRepo) {
     }
     return cachePath;
 }
+/**
+ * Resolve (or create) the Ed25519 publish public key for a package.
+ *
+ * Idempotent: never rotates an established key. Reuses `existingPublishPublicKey`
+ * when present, derives the public key from an existing secret pvar when possible,
+ * and only generates a new keypair when both are missing.
+ *
+ * @throws When a readable secret key does not match an established `publishPublicKey`.
+ */
+async function ensurePackageSigningKey(opts) {
+    const { personalContext, packageId, packageName, existingPublishPublicKey } = opts;
+    const establishedKey = existingPublishPublicKey?.trim() || "";
+    if (personalContext) {
+        const keyName = `${package_author_signing_1.PACKAGE_SIGNING_KEY_PREFIX}${packageId}`;
+        const existingKey = await (0, persistent_vars_1.PersistentVars)(personalContext).findOne({ name: keyName });
+        const rawSecret = existingKey?.value?.value;
+        if (typeof rawSecret === "string" && rawSecret.length > 0) {
+            try {
+                const derivedPublicKey = (0, keys_1.hydrateKeys)(rawSecret).publicKey;
+                if (establishedKey && derivedPublicKey !== establishedKey) {
+                    throw new Error(`Package signing key mismatch for "${packageName}" (${packageId}): ` +
+                        "stored secret does not match Packages.publishPublicKey. " +
+                        "Refusing to rotate the established key.");
+                }
+                return establishedKey || derivedPublicKey;
+            }
+            catch (err) {
+                if (err instanceof Error && err.message.includes("signing key mismatch")) {
+                    throw err;
+                }
+                // Secret is likely encrypted at rest — cannot derive here without the user key.
+                if (establishedKey) {
+                    return establishedKey;
+                }
+                throw new Error(`Package "${packageName}" (${packageId}) has a signing secret pvar but no ` +
+                    "publishPublicKey, and the secret could not be hydrated. " +
+                    "Restore publishPublicKey or replace the unreadable key before importing.");
+            }
+        }
+    }
+    if (establishedKey) {
+        return establishedKey;
+    }
+    if (!personalContext) {
+        return "";
+    }
+    const keys = (0, keys_1.newKeys)();
+    const keyName = `${package_author_signing_1.PACKAGE_SIGNING_KEY_PREFIX}${packageId}`;
+    await (0, persistent_vars_1.PersistentVars)(personalContext).save({
+        persistentVarId: (0, utils_1.deterministicPvarId)(keyName),
+        name: keyName,
+        scope: "user",
+        value: { value: keys.secretKey },
+        isSecret: true,
+        description: `Signing key for package "${packageName}"`,
+        modifiedAt: Date.now(),
+    });
+    return keys.publicKey;
+}
+async function registerPackageRecord(dataContext, opts) {
+    const { packageId, name, description, publishPublicKey, remoteRepo, existing } = opts;
+    await (0, packages_1.Packages)(dataContext).signAndSave({
+        packageId,
+        name,
+        description: description || existing?.description || "",
+        createdBy: existing?.createdBy || system_ids_1.peersRootUserId,
+        disabled: existing?.disabled ?? false,
+        remoteRepo: remoteRepo || existing?.remoteRepo,
+        activePackageVersionId: existing?.activePackageVersionId,
+        versionFollowRange: existing?.versionFollowRange,
+        followVersionTags: existing?.followVersionTags,
+        updateUrl: existing?.updateUrl,
+        publishPublicKey: publishPublicKey || existing?.publishPublicKey || "",
+        signature: existing?.signature || "",
+    }, { restoreIfDeleted: true, saveAsSnapshot: true });
+}
+async function persistPackageLocalPath(dataContext, deps, packageId, location) {
+    const pvar = (0, persistent_vars_1.groupDeviceVar)(`packageLocalPath_${packageId}`, {
+        defaultValue: deps.packagesRootDir,
+        dataContext,
+    });
+    await pvar.loadingPromise;
+    pvar(location);
+}
+/**
+ * Import an existing on-disk Peers package directory into the current data context.
+ *
+ * Validates the manifest packageId, creates/updates the Packages record, persists
+ * `packageLocalPath_*`, provisions a signing key when missing, then installs the
+ * local dev bundles.
+ */
+async function importExistingPackage(dataContext, deps, opts) {
+    const info = await (0, package_installer_1.getPackageInfo)(deps, opts.location);
+    if (!info.packageId) {
+        throw new Error(`Directory already exists at ${opts.location} but does not contain a valid Peers package`);
+    }
+    const packageId = info.packageId;
+    const existing = await (0, packages_1.Packages)(dataContext).get(packageId);
+    const packageName = opts.displayName || info.name || packageId;
+    const publishPublicKey = await ensurePackageSigningKey({
+        personalContext: opts.personalContext,
+        packageId,
+        packageName,
+        existingPublishPublicKey: existing?.publishPublicKey,
+    });
+    await registerPackageRecord(dataContext, {
+        packageId,
+        name: packageName,
+        description: info.description || "",
+        publishPublicKey,
+        remoteRepo: info.remoteRepo,
+        existing,
+    });
+    await persistPackageLocalPath(dataContext, deps, packageId, opts.location);
+    const result = await (0, package_installer_1.installPackageFromBundles)(dataContext, deps, packageId, {
+        localPath: opts.location,
+    });
+    return {
+        packageId,
+        localPath: opts.location,
+        packageVersion: result.packageVersion,
+    };
+}
 /**
  * Create a new Peers package from the package template.
  *
  * Clones the template repo, patches IDs and metadata, runs npm install + build,
  * initializes a fresh git repo, then delegates to {@link installPackageFromBundles}
  * to register the dev bundle in the database.
+ *
+ * When `location` already exists and contains a valid Peers package manifest,
+ * imports that directory instead (see {@link importExistingPackage}).
  */
 async function createPackage(dataContext, deps, opts) {
     const location = opts.location ?? deps.resolvePath(deps.packagesRootDir, nameToFolderSlug(opts.name));
     // If directory already exists, treat as an import rather than a fresh create
     if (await deps.fs.exists(location)) {
-        const info = await (0, package_installer_1.getPackageInfo)(deps, location);
-        if (info.packageId) {
-            const result = await (0, package_installer_1.installPackageFromBundles)(dataContext, deps, info.packageId, {
-                localPath: location,
-            });
-            return {
-                packageId: info.packageId,
-                localPath: location,
-                packageVersion: result.packageVersion,
-            };
-        }
-        throw new Error(`Directory already exists at ${location} but does not contain a valid Peers package`);
+        return importExistingPackage(dataContext, deps, {
+            location,
+            personalContext: opts.personalContext,
+            displayName: opts.name,
+        });
     }
     // Generate fresh IDs
     const packageId = (0, utils_1.newid)();
@@ -110,39 +231,18 @@ async function createPackage(dataContext, deps, opts) {
     await deps.shell.exec("git init", { cwd: location });
     await deps.shell.exec("git add .", { cwd: location });
     await deps.shell.exec('git commit -m "Initial commit"', { cwd: location });
-    // Generate signing keypair and store secret in user's personal group
-    let publishPublicKey = "";
-    if (opts.personalContext) {
-        const keys = (0, keys_1.newKeys)();
-        publishPublicKey = keys.publicKey;
-        const keyName = `${package_author_signing_1.PACKAGE_SIGNING_KEY_PREFIX}${packageId}`;
-        await (0, persistent_vars_1.PersistentVars)(opts.personalContext).save({
-            persistentVarId: (0, utils_1.deterministicPvarId)(keyName),
-            name: keyName,
-            scope: "user",
-            value: { value: keys.secretKey },
-            isSecret: true,
-            description: `Signing key for package "${opts.name}"`,
-            modifiedAt: Date.now(),
-        });
-    }
-    // Register the package record
-    await (0, packages_1.Packages)(dataContext).signAndSave({
+    const publishPublicKey = await ensurePackageSigningKey({
+        personalContext: opts.personalContext,
+        packageId,
+        packageName: opts.name,
+    });
+    await registerPackageRecord(dataContext, {
         packageId,
         name: opts.name,
         description: "",
-        createdBy: system_ids_1.peersRootUserId,
-        disabled: false,
         publishPublicKey,
-        signature: "",
-    }, { restoreIfDeleted: true, saveAsSnapshot: true });
-    // Set the packageLocalPath device var
-    const pvar = (0, persistent_vars_1.groupDeviceVar)(`packageLocalPath_${packageId}`, {
-        defaultValue: deps.packagesRootDir,
-        dataContext,
     });
-    await pvar.loadingPromise;
-    pvar(location);
+    await persistPackageLocalPath(dataContext, deps, packageId, location);
     // Install the dev bundle
     const result = await (0, package_installer_1.installPackageFromBundles)(dataContext, deps, packageId, {
         localPath: location,

package/dist/package-installer/package-creator.test.js

@@ -3,17 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const package_creator_1 = require("./package-creator");
 // --- Mocks for SDK internals ---
 const mockSignAndSavePkg = jest.fn();
+const mockGetPkg = jest.fn();
 jest.mock("../data/packages", () => ({
     Packages: () => ({
         signAndSave: mockSignAndSavePkg,
+        get: mockGetPkg,
     }),
 }));
 const mockGroupDeviceVar = jest.fn();
 const mockPersistentVarsSave = jest.fn();
+const mockPersistentVarsFindOne = jest.fn();
 jest.mock("../data/persistent-vars", () => ({
     groupDeviceVar: (...args) => mockGroupDeviceVar(...args),
     PersistentVars: () => ({
         save: mockPersistentVarsSave,
+        findOne: mockPersistentVarsFindOne,
     }),
 }));
 const mockNewKeys = jest.fn();
@@ -70,6 +74,13 @@ function mockDataContext() {
 // --- Tests ---
 beforeEach(() => {
     jest.clearAllMocks();
+    mockGetPkg.mockResolvedValue(undefined);
+    mockPersistentVarsFindOne.mockResolvedValue(undefined);
+    mockNewKeys.mockReturnValue({
+        publicKey: "test-public-key-abc",
+        secretKey: "test-secret-key-xyz",
+        publicBoxKey: "test-box-key",
+    });
 });
 describe("nameToFolderSlug", () => {
     it("converts a simple name", () => {
@@ -170,16 +181,18 @@ describe("createPackage", () => {
         expect(result.localPath).toBe("/packages/my-widget");
         expect(result.packageVersion).toBe(mockPv);
     });
-    it("delegates to installPackageFromBundles when directory already exists with valid package", async () => {
+    it("registers metadata, path, and signing key when importing an existing package directory", async () => {
         const deps = makeMockDeps({});
         const dc = mockDataContext();
-        // Location exists
+        const personalCtx = mockDataContext();
         deps.fs.exists.mockResolvedValue(true);
-        // getPackageInfo returns a valid packageId
         mockGetPackageInfo.mockResolvedValue({
             packageId: "00mnkoyo7mizav6tseubjzr3a",
             name: "existing-pkg",
+            description: "Imported package",
         });
+        const pvarSetter = jest.fn();
+        mockGroupDeviceVar.mockReturnValue(pvarSetter);
         const mockPv = { packageVersionId: "pv002", packageId: "00mnkoyo7mizav6tseubjzr3a" };
         mockInstallPackageFromBundles.mockResolvedValue({
             packageVersion: mockPv,
@@ -187,16 +200,67 @@ describe("createPackage", () => {
             unchanged: false,
         });
         const result = await (0, package_creator_1.createPackage)(dc, deps, {
-            name: "existing-pkg",
+            name: "Existing Pkg",
             location: "/custom/path",
+            personalContext: personalCtx,
         });
-        // Should NOT clone
         expect(deps.shell.exec).not.toHaveBeenCalled();
-        // Should delegate to install
+        expect(mockGetPkg).toHaveBeenCalledWith("00mnkoyo7mizav6tseubjzr3a");
+        expect(mockNewKeys).toHaveBeenCalled();
+        expect(mockPersistentVarsSave).toHaveBeenCalledWith(expect.objectContaining({
+            name: "packageSigningKey_00mnkoyo7mizav6tseubjzr3a",
+            isSecret: true,
+            value: { value: "test-secret-key-xyz" },
+        }));
+        expect(mockSignAndSavePkg).toHaveBeenCalledWith(expect.objectContaining({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            name: "Existing Pkg",
+            description: "Imported package",
+            publishPublicKey: "test-public-key-abc",
+        }), { restoreIfDeleted: true, saveAsSnapshot: true });
+        expect(mockGroupDeviceVar).toHaveBeenCalledWith("packageLocalPath_00mnkoyo7mizav6tseubjzr3a", expect.any(Object));
+        expect(pvarSetter).toHaveBeenCalledWith("/custom/path");
         expect(mockInstallPackageFromBundles).toHaveBeenCalledWith(dc, deps, "00mnkoyo7mizav6tseubjzr3a", { localPath: "/custom/path" });
         expect(result.packageId).toBe("00mnkoyo7mizav6tseubjzr3a");
         expect(result.localPath).toBe("/custom/path");
     });
+    it("reuses an existing publishPublicKey and does not rotate the signing key on re-import", async () => {
+        const deps = makeMockDeps({});
+        const dc = mockDataContext();
+        const personalCtx = mockDataContext();
+        deps.fs.exists.mockResolvedValue(true);
+        mockGetPackageInfo.mockResolvedValue({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            name: "existing-pkg",
+        });
+        mockGetPkg.mockResolvedValue({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            name: "existing-pkg",
+            description: "Old description",
+            createdBy: "00m87fbwu96jzf8qnwllly0fd",
+            publishPublicKey: "already-established-public-key",
+            signature: "sig",
+            disabled: false,
+        });
+        const pvarSetter = jest.fn();
+        mockGroupDeviceVar.mockReturnValue(pvarSetter);
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv002", packageId: "00mnkoyo7mizav6tseubjzr3a" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        await (0, package_creator_1.createPackage)(dc, deps, {
+            name: "existing-pkg",
+            location: "/custom/path",
+            personalContext: personalCtx,
+        });
+        expect(mockNewKeys).not.toHaveBeenCalled();
+        expect(mockPersistentVarsSave).not.toHaveBeenCalled();
+        expect(mockSignAndSavePkg).toHaveBeenCalledWith(expect.objectContaining({
+            publishPublicKey: "already-established-public-key",
+            createdBy: "00m87fbwu96jzf8qnwllly0fd",
+        }), expect.any(Object));
+    });
     it("throws when directory exists but has no valid package", async () => {
         const deps = makeMockDeps({});
         const dc = mockDataContext();
@@ -268,11 +332,6 @@ describe("createPackage", () => {
             loaded: undefined,
             unchanged: false,
         });
-        mockNewKeys.mockReturnValue({
-            publicKey: "test-public-key-abc",
-            secretKey: "test-secret-key-xyz",
-            publicBoxKey: "test-box-key",
-        });
         await (0, package_creator_1.createPackage)(dc, deps, {
             name: "Signed Pkg",
             personalContext: personalCtx,
@@ -319,6 +378,49 @@ describe("createPackage", () => {
         }), expect.any(Object));
     });
 });
+describe("ensurePackageSigningKey", () => {
+    it("generates a key once when none exists", async () => {
+        const personalCtx = mockDataContext();
+        const publicKey = await (0, package_creator_1.ensurePackageSigningKey)({
+            personalContext: personalCtx,
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            packageName: "Test Pkg",
+        });
+        expect(publicKey).toBe("test-public-key-abc");
+        expect(mockNewKeys).toHaveBeenCalledTimes(1);
+        expect(mockPersistentVarsSave).toHaveBeenCalledTimes(1);
+    });
+    it("reuses an established publishPublicKey without generating a new key", async () => {
+        const personalCtx = mockDataContext();
+        const publicKey = await (0, package_creator_1.ensurePackageSigningKey)({
+            personalContext: personalCtx,
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            packageName: "Test Pkg",
+            existingPublishPublicKey: "established-key",
+        });
+        expect(publicKey).toBe("established-key");
+        expect(mockNewKeys).not.toHaveBeenCalled();
+        expect(mockPersistentVarsSave).not.toHaveBeenCalled();
+    });
+    it("throws on an unrecoverable public/private key mismatch", async () => {
+        const { newKeys: realNewKeys } = jest.requireActual("../keys");
+        const realKeys = realNewKeys();
+        const otherKeys = realNewKeys();
+        const personalCtx = mockDataContext();
+        mockPersistentVarsFindOne.mockResolvedValue({
+            name: "packageSigningKey_00mnkoyo7mizav6tseubjzr3a",
+            value: { value: realKeys.secretKey },
+            isSecret: true,
+        });
+        await expect((0, package_creator_1.ensurePackageSigningKey)({
+            personalContext: personalCtx,
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            packageName: "Test Pkg",
+            existingPublishPublicKey: otherKeys.publicKey,
+        })).rejects.toThrow("signing key mismatch");
+        expect(mockNewKeys).not.toHaveBeenCalled();
+    });
+});
 describe("ensureTemplateCache", () => {
     it("clones template when cache directory does not exist", async () => {
         const deps = makeMockDeps({});

package/dist/rpc-types.d.ts

@@ -174,23 +174,6 @@ export declare const rpcServerCalls: {
         success: boolean;
         error?: string;
     }>;
-    voiceGetState: () => Promise<{
-        state: "disabled" | "idle" | "listening" | "recording" | "processing" | "speaking";
-        keyError?: "refused" | "invalid" | "limit" | "throttled";
-    }>;
-    voiceStartRecording: () => Promise<void>;
-    voiceStopRecording: () => Promise<void>;
-    voiceCancelRecording: () => Promise<void>;
-    voiceSetTargetChannel: (channelId: string) => Promise<void>;
-    voiceGetAudioDevices: () => Promise<string[]>;
-    voiceTestTTS: (text: string) => Promise<void>;
-    voiceNotifyPlaybackComplete: () => Promise<void>;
-    voiceStopPlayback: () => Promise<void>;
-    voiceGetThreadId: () => Promise<string | null>;
-    voiceSetThreadId: (threadId: string | null) => Promise<void>;
-    voiceNotifyTextActivity: () => Promise<void>;
-    voiceDisable: () => Promise<void>;
-    voiceEnable: () => Promise<void>;
     flushDatabases: () => Promise<void>;
     subscribeEvents: (names: string[]) => Promise<void>;
     unsubscribeEvents: (names: string[]) => Promise<void>;

package/dist/rpc-types.js

@@ -84,21 +84,6 @@ exports.rpcServerCalls = {
     uiClick: rpcStub("uiClick"),
     uiSet: rpcStub("uiSet"),
     uiScroll: rpcStub("uiScroll"),
-    // Voice control (settings managed via voiceSettings pvar, keys via secret pvars)
-    voiceGetState: rpcStub("voiceGetState"),
-    voiceStartRecording: rpcStub("voiceStartRecording"),
-    voiceStopRecording: rpcStub("voiceStopRecording"),
-    voiceCancelRecording: rpcStub("voiceCancelRecording"),
-    voiceSetTargetChannel: rpcStub("voiceSetTargetChannel"),
-    voiceGetAudioDevices: rpcStub("voiceGetAudioDevices"),
-    voiceTestTTS: rpcStub("voiceTestTTS"),
-    voiceNotifyPlaybackComplete: rpcStub("voiceNotifyPlaybackComplete"),
-    voiceStopPlayback: rpcStub("voiceStopPlayback"),
-    voiceGetThreadId: rpcStub("voiceGetThreadId"),
-    voiceSetThreadId: rpcStub("voiceSetThreadId"),
-    voiceNotifyTextActivity: rpcStub("voiceNotifyTextActivity"),
-    voiceDisable: rpcStub("voiceDisable"),
-    voiceEnable: rpcStub("voiceEnable"),
     // Flush all in-memory database snapshots to durable storage (IndexedDB in PWA).
     // No-op on Electron where better-sqlite3 writes are synchronous to disk.
     flushDatabases: (async () => { }),

package/dist/system-ids.d.ts

@@ -4,6 +4,8 @@ export declare const peersRootUserId = "000peers0user000000000001";
 export declare const defaultAssistantId = "000peers0bot00000000shell";
 /** Stable ID of the bundled OpenCode assistant. */
 export declare const openCodeAssistantId = "00mlwl2km2opencode0000001";
+/** Stable ID of the built-in Admin assistant. */
+export declare const adminAssistantId = "000peers0bot00000000admin";
 /** Stable ID of the default assistant-runner tool. */
 export declare const defaultAssistantRunnerToolId = "000peers0tool00000runner1";
 /** Stable ID of the built-in send-message tool. */
@@ -36,3 +38,14 @@ export declare const deviceOperationsContractId = "00mriijkhq94msfe9m2j6quwp";
 export declare const networkDiagnosticsContractId = "00ms1yb50w29oi116uwwrg7rl";
 /** Contract id for explicit local network and synchronization control operations. */
 export declare const networkControlContractId = "00ms1yb50yj9w5qbytl69qfht";
+/**
+ * Contract id for the local-only tool-access approval control surface.
+ * Not available over device-to-device connections.
+ */
+export declare const toolAccessControlContractId = "000peers0toolaccessctl0001";
+/** Stable IDs for tools in System Tool Access Control v1. */
+export declare const toolAccessControlToolIds: {
+    readonly approve: "000peers0tacapprove000001";
+    readonly reject: "000peers0tacreject0000001";
+    readonly listPending: "000peers0taclist000000001";
+};