@noodleseed/one 0.177.0 → 0.178.0

package/node_modules/@noodle-borg/authoring/dist/assistant.js

@@ -5,7 +5,7 @@ export function publicMessaging(input) {
         throw new Error('publicMessaging requires an explicit capability allowlist');
     }
     for (const key of Object.keys(input)) {
-        if (!['channel', 'capabilities', 'instructions'].includes(key)) {
+        if (!['channel', 'capabilities', 'instructions', 'history'].includes(key)) {
             throw new Error(`publicMessaging does not accept ${key}`);
         }
     }
@@ -17,6 +17,7 @@ export function publicMessaging(input) {
         channel: input.channel,
         capabilities: normalizeCapabilities(input.capabilities),
         ...(input.instructions === undefined ? {} : { instructions: input.instructions }),
+        ...historyOptOut(input.history),
     };
 }
 export function authenticatedWebsite(input) {
@@ -27,6 +28,7 @@ export function authenticatedWebsite(input) {
         ...(input.sessionClaims ? { sessionClaims: structuredClone(input.sessionClaims) } : {}),
         ...(input.capabilities ? { capabilities: [...input.capabilities] } : {}),
         ...(input.webmcp === undefined ? {} : { webmcp: { ...input.webmcp } }),
+        ...historyOptOut(input.history),
     };
 }
 export function publicWebsite(input) {
@@ -37,8 +39,18 @@ export function publicWebsite(input) {
         ...(input.instructions === undefined ? {} : { instructions: input.instructions }),
         ...(input.webmcp === undefined ? {} : { webmcp: { ...input.webmcp } }),
         ...(input.continuity === undefined ? {} : { continuity: { ...input.continuity } }),
+        ...historyOptOut(input.history),
     };
 }
+/** Refuses anything but the literal `false`, because days are operator state (ADR 0212). */
+function historyOptOut(history) {
+    if (history === undefined)
+        return {};
+    if (history !== false) {
+        throw new Error('history accepts only false (this surface never keeps chats); how many days a recorded surface keeps is the business setting in noodle solutions history settings');
+    }
+    return { history: false };
+}
 function serializeOrigins(origins, path) {
     return origins.map((origin, index) => typeof origin === 'string' ? origin : serializeVariableRef(origin, `${path}.${index}`));
 }
@@ -88,6 +100,7 @@ export function embeddedAssistant(input) {
                 ...(surface.mode !== 'authenticated' && surface.continuity !== undefined
                     ? { continuity: { ...surface.continuity } }
                     : {}),
+                ...(surface.history === false ? { history: false } : {}),
             }),
         allowedOrigins: surfaces.flatMap((surface) => surface.kind === 'messaging' ? [] : [...surface.origins]),
         ...structuredClone(ui),

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-channels.js

@@ -114,9 +114,6 @@ export const CHANNELS_COMMAND = {
                     ...mutation,
                 ]),
             ]),
-            group('conversation', 'Erase conversation content.', [
-                leaf('forget', 'Erase participant context and message content while preserving safeguards.', [participant, ...mutation]),
-            ]),
         ]),
     ],
 };

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-solution-conversations.js

@@ -1,5 +1,14 @@
 /** Staff conversation history operations (ADR 0241); imported by the solutions family. Data only. */
 import { INSTALLATION_ARGUMENT, OPTIONAL_FLAG, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
+const STATUS_CHOICES = ['new', 'needs-attention', 'reviewed'];
+const CONVERSATION_FLAG = {
+    ...OPTIONAL_FLAG,
+    required: true,
+    name: 'conversation',
+    type: 'string',
+    value: '<id>',
+    summary: 'Conversation id from conversations list.',
+};
 const paging = (maximum) => [
     {
         ...OPTIONAL_FLAG,
@@ -24,6 +33,14 @@ const paging = (maximum) => [
         summary: 'Only conversations from this channel.',
         constraints: { choices: ['website', 'whatsapp'] },
     },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'status',
+        type: 'string',
+        value: '<status>',
+        summary: 'Only conversations with this review status.',
+        constraints: { choices: STATUS_CHOICES },
+    },
 ];
 const SELECTORS = ['conversation', 'customer', 'participant'];
 const SELECTOR_SUMMARIES = {
@@ -33,7 +50,7 @@ const SELECTOR_SUMMARIES = {
 };
 export const SOLUTION_CONVERSATIONS = {
     name: 'conversations',
-    summary: 'Read, export and forget customer conversation history.',
+    summary: 'Read, review, note, export and forget customer conversation history.',
     arguments: [],
     flags: [],
     subcommands: [
@@ -46,17 +63,45 @@ export const SOLUTION_CONVERSATIONS = {
         },
         {
             name: 'show',
-            summary: 'Show one conversation with its messages; the read is audited.',
+            summary: 'Show one conversation with its messages and private notes; the read is audited.',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: [...SOLUTION_COMMON_FLAGS, CONVERSATION_FLAG],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'review',
+            summary: 'Set the review status of one conversation (Operator or above); audited.',
+            arguments: [INSTALLATION_ARGUMENT],
+            flags: [
+                ...SOLUTION_COMMON_FLAGS,
+                CONVERSATION_FLAG,
+                {
+                    ...OPTIONAL_FLAG,
+                    required: true,
+                    name: 'status',
+                    type: 'string',
+                    value: '<status>',
+                    summary: 'New review status.',
+                    constraints: { choices: STATUS_CHOICES },
+                },
+            ],
+            jsonOutput: { mode: 'single' },
+        },
+        {
+            name: 'note',
+            summary: 'Add a private staff note the customer never sees (Operator or above); audited.',
             arguments: [INSTALLATION_ARGUMENT],
             flags: [
                 ...SOLUTION_COMMON_FLAGS,
+                CONVERSATION_FLAG,
                 {
                     ...OPTIONAL_FLAG,
                     required: true,
-                    name: 'conversation',
+                    name: 'text',
                     type: 'string',
-                    value: '<id>',
-                    summary: 'Conversation id from conversations list.',
+                    value: '<text>',
+                    summary: 'Note text, up to 2000 characters.',
+                    constraints: { maxLength: 2000 },
                 },
             ],
             jsonOutput: { mode: 'single' },

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-solution-history.js

@@ -0,0 +1,82 @@
+/** The installation history setting (ADR 0241 decision 6); imported by the solutions family. Data only. */
+import { INSTALLATION_ARGUMENT, OPTIONAL_FLAG, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
+const days = (name, summary, conflictsWith = []) => ({
+    ...OPTIONAL_FLAG,
+    name,
+    type: 'integer',
+    value: '<days>',
+    summary,
+    constraints: { minimum: 1, maximum: 365 },
+    conflictsWith,
+});
+const channel = (name, summary) => ({
+    ...OPTIONAL_FLAG,
+    name,
+    type: 'string',
+    value: '<on|off>',
+    summary,
+    constraints: { choices: ['on', 'off'] },
+});
+export const SOLUTION_HISTORY = {
+    name: 'history',
+    summary: 'Inspect or change how long Activity and conversations are kept.',
+    arguments: [],
+    flags: [],
+    subcommands: [
+        {
+            name: 'settings',
+            summary: 'Read or change the installation history setting within plan limits.',
+            arguments: [],
+            flags: [],
+            subcommands: [
+                {
+                    name: 'get',
+                    summary: 'Read Activity and conversation durations, recording switches, edit permission and revision.',
+                    arguments: [INSTALLATION_ARGUMENT],
+                    flags: SOLUTION_COMMON_FLAGS,
+                    jsonOutput: { mode: 'single' },
+                },
+                {
+                    name: 'set',
+                    summary: 'Change durations or recording switches with a revision check; shortening or turning off conversations needs --confirm.',
+                    arguments: [INSTALLATION_ARGUMENT],
+                    flags: [
+                        ...SOLUTION_COMMON_FLAGS,
+                        days('activity-days', 'Days to keep Activity, within the plan maximum.'),
+                        days('conversation-days', 'Days to keep conversations; turns recording on.', [
+                            'conversations',
+                        ]),
+                        {
+                            ...OPTIONAL_FLAG,
+                            name: 'conversations',
+                            type: 'string',
+                            value: 'off',
+                            summary: 'Turn conversation recording off.',
+                            constraints: { choices: ['off'] },
+                            conflictsWith: ['conversation-days'],
+                        },
+                        channel('website-visitors', 'Record anonymous website visitors.'),
+                        channel('signed-in-customers', 'Record signed-in customers.'),
+                        channel('whatsapp', 'Record WhatsApp conversations.'),
+                        {
+                            ...OPTIONAL_FLAG,
+                            required: true,
+                            name: 'expected-revision',
+                            type: 'string',
+                            value: '<hash>',
+                            summary: 'Revision returned by history settings get.',
+                        },
+                        {
+                            ...OPTIONAL_FLAG,
+                            name: 'confirm',
+                            type: 'boolean',
+                            summary: 'Confirm a change that shortens or turns off conversation history; without it the effect is shown and nothing is saved.',
+                        },
+                    ],
+                    jsonOutput: { mode: 'single' },
+                },
+            ],
+        },
+    ],
+};
+//# sourceMappingURL=catalog-data-solution-history.js.map

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-solutions.js

@@ -2,6 +2,7 @@
 import { SOLUTION_CONVERSATIONS } from './catalog-data-solution-conversations.js';
 import { SOLUTION_DRAFTS } from './catalog-data-solution-drafts.js';
 import { AUTH_TOKEN, EXPECTED_REVISION, IDEMPOTENCY_KEY, INSTALLATION_ARGUMENT, JSON_FLAG, OPTIONAL_FLAG, PAGING_FLAGS, REQUIRED_ARGUMENT, SERVICE, SOLUTION_COMMON_FLAGS, } from './catalog-data-solution-flags.js';
+import { SOLUTION_HISTORY } from './catalog-data-solution-history.js';
 import { SOLUTION_PAGE } from './catalog-data-solution-page.js';
 import { COLLECTION_ARGUMENT, SOLUTION_RECORDS } from './catalog-data-solution-records.js';
 import { SOLUTION_WORKSPACE } from './catalog-data-solution-workspace.js';
@@ -173,9 +174,10 @@ export const CATALOG_SOLUTIONS = {
             ],
         },
         SOLUTION_CONVERSATIONS,
+        SOLUTION_HISTORY,
         {
             name: 'activity',
-            summary: 'Inspect payload-free operation evidence and its retention policy.',
+            summary: 'Inspect payload-free operation evidence and preview plan history impact.',
             arguments: [],
             flags: [],
             subcommands: [
@@ -212,47 +214,6 @@ export const CATALOG_SOLUTIONS = {
                     flags: SOLUTION_COMMON_FLAGS,
                     jsonOutput: { mode: 'single' },
                 },
-                {
-                    name: 'settings',
-                    summary: 'Inspect or change Activity retention within plan limits.',
-                    arguments: [],
-                    flags: [],
-                    subcommands: [
-                        {
-                            name: 'get',
-                            summary: 'Read retention, plan maximum, edit permission and current revision.',
-                            arguments: [INSTALLATION_ARGUMENT],
-                            flags: SOLUTION_COMMON_FLAGS,
-                            jsonOutput: { mode: 'single' },
-                        },
-                        {
-                            name: 'set',
-                            summary: 'Change retention with an explicit revision check.',
-                            arguments: [INSTALLATION_ARGUMENT],
-                            flags: [
-                                ...SOLUTION_COMMON_FLAGS,
-                                {
-                                    ...OPTIONAL_FLAG,
-                                    required: true,
-                                    name: 'retention-days',
-                                    type: 'integer',
-                                    value: '<days>',
-                                    summary: 'Desired retention within the current plan maximum.',
-                                    constraints: { minimum: 1, maximum: 365 },
-                                },
-                                {
-                                    ...OPTIONAL_FLAG,
-                                    required: true,
-                                    name: 'expected-revision',
-                                    type: 'string',
-                                    value: '<hash>',
-                                    summary: 'Revision returned by activity settings get.',
-                                },
-                            ],
-                            jsonOutput: { mode: 'single' },
-                        },
-                    ],
-                },
             ],
         },
         {

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.d.ts

@@ -372,6 +372,7 @@ export declare const manifestV1Schema: z.ZodObject<{
                     name: z.ZodString;
                 }, z.core.$strict>>;
                 instructions: z.ZodOptional<z.ZodString>;
+                history: z.ZodOptional<z.ZodLiteral<false>>;
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodOptional<z.ZodLiteral<"website">>;
                 mode: z.ZodEnum<{
@@ -401,6 +402,7 @@ export declare const manifestV1Schema: z.ZodObject<{
                     windowSeconds: z.ZodOptional<z.ZodNumber>;
                     maxRestores: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>>;
+                history: z.ZodOptional<z.ZodLiteral<false>>;
             }, z.core.$strict>]>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
@@ -876,6 +878,7 @@ export declare const manifestV2Schema: z.ZodObject<{
                     name: z.ZodString;
                 }, z.core.$strict>>;
                 instructions: z.ZodOptional<z.ZodString>;
+                history: z.ZodOptional<z.ZodLiteral<false>>;
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodOptional<z.ZodLiteral<"website">>;
                 mode: z.ZodEnum<{
@@ -905,6 +908,7 @@ export declare const manifestV2Schema: z.ZodObject<{
                     windowSeconds: z.ZodOptional<z.ZodNumber>;
                     maxRestores: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>>;
+                history: z.ZodOptional<z.ZodLiteral<false>>;
             }, z.core.$strict>]>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
@@ -1674,6 +1678,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     name: z.ZodString;
                 }, z.core.$strict>>;
                 instructions: z.ZodOptional<z.ZodString>;
+                history: z.ZodOptional<z.ZodLiteral<false>>;
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodOptional<z.ZodLiteral<"website">>;
                 mode: z.ZodEnum<{
@@ -1703,6 +1708,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     windowSeconds: z.ZodOptional<z.ZodNumber>;
                     maxRestores: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>>;
+                history: z.ZodOptional<z.ZodLiteral<false>>;
             }, z.core.$strict>]>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
@@ -2177,6 +2183,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     name: z.ZodString;
                 }, z.core.$strict>>;
                 instructions: z.ZodOptional<z.ZodString>;
+                history: z.ZodOptional<z.ZodLiteral<false>>;
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodOptional<z.ZodLiteral<"website">>;
                 mode: z.ZodEnum<{
@@ -2206,6 +2213,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     windowSeconds: z.ZodOptional<z.ZodNumber>;
                     maxRestores: z.ZodOptional<z.ZodNumber>;
                 }, z.core.$strict>>;
+                history: z.ZodOptional<z.ZodLiteral<false>>;
             }, z.core.$strict>]>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.js

@@ -269,6 +269,11 @@ const assistantCapabilitySchema = z
 const MAX_SERVER_INSTRUCTIONS = 4000;
 /** Verified session claims an embedding backend may pass at exchange; undeclared keys are dropped. */
 const sessionClaimsSchema = z.record(z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/, 'claim keys are identifier-style'), z.object({ exposeToModel: z.boolean().optional() }).strict());
+/**
+ * `false` means this surface's chats are never kept as history (ADR 0241 decision 11). Only the literal
+ * is accepted: a number of days is operator state (ADR 0212), so a count is refused, never read.
+ */
+const surfaceHistorySchema = z.literal(false).optional();
 const embeddedAssistantSchema = z
     .object({
     model: z.union([
@@ -297,6 +302,7 @@ const embeddedAssistantSchema = z
             mode: z.literal('public'),
             capabilities: z.array(assistantCapabilitySchema),
             instructions: z.string().trim().min(1).max(MAX_SERVER_INSTRUCTIONS).optional(),
+            history: surfaceHistorySchema,
         })
             .strict(),
         z
@@ -324,6 +330,7 @@ const embeddedAssistantSchema = z
                 windowSeconds: z.number().int().min(0).max(600).optional(),
                 maxRestores: z.number().int().min(0).max(10).optional(),
             }),
+            history: surfaceHistorySchema,
         })
             .strict(),
     ]))

package/node_modules/@noodle-borg/service/dist/application-activity.js

@@ -1,6 +1,7 @@
 import { createHmac } from 'node:crypto';
 import { canonicalJson, sha256Canonical } from '@noodle-borg/compiler';
-import { ApplicationActivityListResponseSchema, ApplicationActivityPreviewResponseSchema, ApplicationActivitySettingsResponseSchema, ApplicationActivitySettingsSaveRequestSchema, OperationCoordinationListRequestSchema, OperationCoordinationListResponseSchema, OperationCoordinationResolveRequestSchema, OperationCoordinationResolveResponseSchema, } from '@noodle-borg/wire-contracts';
+import { ApplicationActivityListResponseSchema, ApplicationActivityPreviewResponseSchema, ApplicationHistorySettingsResponseSchema, ApplicationHistorySettingsSaveRequestSchema, ApplicationHistorySettingsSaveResponseSchema, OperationCoordinationListRequestSchema, OperationCoordinationListResponseSchema, OperationCoordinationResolveRequestSchema, OperationCoordinationResolveResponseSchema, } from '@noodle-borg/wire-contracts';
+import { conversationPolicyFromSetting, historySettingsProjection, lazyHistorySetting, newInstallationHistorySetting, planHistorySettingsChange, } from './application-history-settings.js';
 import { resolveApplicationRuntimeTarget } from './application-runtime-target.js';
 import { createOperationCoordinationPort, } from './operation-coordination.js';
 import { createOperationEvidencePort, } from './operation-evidence.js';
@@ -111,11 +112,13 @@ export class ApplicationActivity {
             });
         }
         if (action === 'save-settings') {
-            const parsed = ApplicationActivitySettingsSaveRequestSchema.safeParse(input.body);
+            const parsed = ApplicationHistorySettingsSaveRequestSchema.safeParse(input.body);
             if (!parsed.success)
                 throw invalid();
-            const data = await this.save(scope, parsed.data, local);
-            return mutation(ApplicationActivitySettingsResponseSchema.parse({ ok: true, data }), 'config.activity.retention_changed', { retentionDays: data.retentionDays });
+            const { audit, ...saved } = await this.save(scope, parsed.data, local);
+            const data = { ...saved, settings: await this.withApplicationView(scope, saved.settings) };
+            const response = ApplicationHistorySettingsSaveResponseSchema.parse({ ok: true, data });
+            return audit ? mutation(response, 'config.history.settings_changed', audit) : { response };
         }
         if (action === 'preview')
             return {
@@ -126,9 +129,9 @@ export class ApplicationActivity {
             };
         if (action === 'settings')
             return {
-                response: ApplicationActivitySettingsResponseSchema.parse({
+                response: ApplicationHistorySettingsResponseSchema.parse({
                     ok: true,
-                    data: (await this.settings(scope, input.canEdit, local)).projection,
+                    data: await this.withApplicationView(scope, (await this.settings(scope, input.canEdit, local)).projection),
                 }),
             };
         const limit = parameters.has('limit') ? Number(parameters.get('limit')) : 50;
@@ -149,7 +152,18 @@ export class ApplicationActivity {
             }),
         };
     }
-    async settings(scope, canEdit, local = runLocal) {
+    /** Adds what the application itself declared; the stored setting and its revision are unchanged. */
+    async withApplicationView(scope, projection) {
+        const disabled = (await this.options.historyDisabledSurfaces?.(scope)) ?? [];
+        if (disabled.length === 0)
+            return projection;
+        return {
+            ...projection,
+            conversations: { ...projection.conversations, disabledByApplication: [...disabled] },
+        };
+    }
+    /** The verified plan allowance, or unavailable; never a default invented locally. */
+    async allowance(scope) {
         const allowance = await this.options.allowance(scope.org);
         if (!allowance ||
             !validDays(allowance.maximumDays) ||
@@ -157,36 +171,77 @@ export class ApplicationActivity {
             allowance.defaultDays > allowance.maximumDays ||
             !allowance.revision)
             throw new ActivityPolicyError('activity_unavailable');
+        return allowance;
+    }
+    async settings(scope, canEdit, local = runLocal) {
+        const allowance = await this.allowance(scope);
         const setting = await local(async () => {
             let value = await this.options.store.readRetention(scope);
             if (!value) {
-                await this.options.store.setRetention(scope, allowance.defaultDays, undefined);
+                await this.options.store.setRetention(scope, lazyHistorySetting(allowance), undefined);
                 value = await this.options.store.readRetention(scope);
             }
             return value;
         });
-        if (!setting || !validDays(setting.days))
+        if (!setting ||
+            !validDays(setting.days) ||
+            (setting.conversationDays !== null &&
+                setting.conversationDays !== 0 &&
+                !validDays(setting.conversationDays)))
             throw new ActivityPolicyError('activity_unavailable');
         return {
             setting,
             allowance,
-            projection: {
-                revision: this.revision(scope, setting, allowance),
-                retentionDays: Math.min(setting.days, allowance.maximumDays),
-                maximumDays: allowance.maximumDays,
-                canEdit,
-            },
+            projection: historySettingsProjection(setting, allowance, this.revision(scope, setting, allowance), canEdit),
         };
     }
+    /**
+     * One change under one revision. Shortening or turning off conversations caps stored expiry right
+     * after the setting is written, so no longer transcript survives behind the shorter window; a dry
+     * run counts exactly what that cap would hide, saves nothing and is not audited.
+     */
     async save(scope, input, local = runLocal) {
         const current = await this.settings(scope, true, local);
         if (current.projection.revision !== input.expectedRevision)
             throw new ActivityPolicyError('activity_conflict');
-        if (!validDays(input.retentionDays) || input.retentionDays > current.allowance.maximumDays)
+        const plan = planHistorySettingsChange(current.setting, input, current.allowance.maximumDays);
+        if (!plan)
             throw new ActivityPolicyError('activity_invalid');
-        if (!(await local(() => this.options.store.setRetention(scope, input.retentionDays, current.setting.revision))))
+        const store = this.options.conversationHistory;
+        const window = (method) => plan.shortened === undefined || !store
+            ? { conversations: 0, items: 0 }
+            : local(() => store[method]({ org: scope.org, app: scope.app, env: scope.env }, { now: this.options.now?.() ?? Date.now(), days: plan.shortened ?? 0 }));
+        const shortensConversations = plan.shortened !== undefined;
+        if (input.dryRun)
+            return {
+                shortensConversations,
+                impact: await window('countOutsideWindow'),
+                dryRun: true,
+                settings: current.projection,
+                audit: undefined,
+            };
+        if (!(await local(() => this.options.store.setRetention(scope, plan.next, current.setting.revision))))
             throw new ActivityPolicyError('activity_conflict');
-        return (await this.settings(scope, true, local)).projection;
+        const impact = await window('capExpiry');
+        return {
+            shortensConversations,
+            impact,
+            dryRun: false,
+            settings: (await this.settings(scope, true, local)).projection,
+            audit: plan.audit,
+        };
+    }
+    /**
+     * Writes a new installation's first setting so it records conversations from day one. Runs only for a
+     * created installation, before anything reads (and lazily creates) a not-enabled setting.
+     */
+    async initializeHistory(scope) {
+        return this.options.store.setRetention(scope, newInstallationHistorySetting(await this.allowance(scope)), undefined);
+    }
+    /** The capture policy: side-effect free, so the capture path never creates a setting. */
+    async conversationPolicy(scope) {
+        const allowance = await this.allowance(scope);
+        return conversationPolicyFromSetting(await this.options.store.readRetention(scope), allowance);
     }
     async page(scope, input, local = runLocal) {
         if (!Number.isInteger(input.limit) || input.limit < 1 || input.limit > 100)
@@ -198,7 +253,7 @@ export class ApplicationActivity {
             revision: policy.revision,
             limit: input.limit,
         });
-        const records = await local(() => this.options.store.list(scope, this.options.now?.() ?? Date.now(), policy.retentionDays, input.limit + 1, decodeActivityCursor(input.cursor, binding)));
+        const records = await local(() => this.options.store.list(scope, this.options.now?.() ?? Date.now(), policy.activity.retentionDays, input.limit + 1, decodeActivityCursor(input.cursor, binding)));
         if ((await this.settings(scope, false, local)).projection.revision !== policy.revision)
             throw new ActivityPolicyError('activity_conflict');
         const page = records.slice(0, input.limit);
@@ -217,7 +272,7 @@ export class ApplicationActivity {
                     : { completedAt: new Date(completedAt).toISOString() }),
                 ...(reference === undefined ? {} : { reference }),
             })),
-            historyDays: policy.retentionDays,
+            historyDays: policy.activity.retentionDays,
             ...(records.length > page.length && last
                 ? {
                     nextCursor: Buffer.from(JSON.stringify({ binding, startedAt: last.startedAt, id: last.id })).toString('base64url'),
@@ -337,7 +392,7 @@ export class ApplicationActivity {
             ...this.options,
             scope,
             deploymentId: target.deploymentId,
-            historyDays: async () => (await this.settings(scope, false)).projection.retentionDays,
+            historyDays: async () => (await this.settings(scope, false)).projection.activity.retentionDays,
             executionBoundMs: (intent) => intent.executionBoundMs,
             connectionGeneration: (id) => target.served.deps.executionBinding?.connections[id] ?? revision,
             authorize,