@dsh-enhanced/assistant-growth-experiments 0.1.12

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-enhanced contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# @dsh-enhanced/assistant-growth-experiments
+
+> **显式启用的受监督能力，非默认能力。** 默认个人助理安装不会加载本包。启用时它只组合
+> `@dsh-enhanced/assistant-growth-contract`、Delivery 和 Automations 的当前 Host 协议；没有这些
+> 精确边界会拒绝启动，绝不降级为接受任意 trace 或模型自报。
+
+这是基于可信、版本化工作流证据的持久成长实验控制器：只接受 Delivery 的结构化 trace
+projection，不让原始工具参数离开其 Host 边界；候选经 owner 审批后，依次执行 replay、阻断
+全部外部副作用的 shadow、至多一次 production canary，并且只有收到 `trusted + achieved` 评估后
+才使用 Automation CAS 提升。其余路径一律回滚。
+
+## 开发者显式安装
+
+```sh
+dsh plugin --profile web add @dsh-enhanced/assistant-growth-experiments
+dsh --profile web --dump-config
+```
+
+## 配置
+
+```yaml
+- id: dsh-enhanced-assistant-growth-experiments
+  name: '@dsh-enhanced/assistant-growth-experiments'
+  inject:
+    - assistantAutomations
+    - assistantDelivery
+  config:
+    databasePath: !!js dshHomePath('assistant-growth-experiments/growth.sqlite')
+    tickIntervalMs: 5000
+    minRepeatedSuccesses: 3
+    maxBatchSize: 10
+    maxExperimentDurationMs: 604800000
+    maxOperationAttempts: 8
+    retryBaseMs: 1000
+    retryMaxMs: 60000
+```
+
+## 证据入口与私有 capability
+
+Delivery 是唯一的 workflow trace producer。Growth 启动时调用
+`registerWorkflowTraceSink({ contractVersion: 1, sink })`，取得固定
+`sourceId: assistantDelivery`、持久 generation、authority digest 和 disposer。该 sink 是只交给
+当前注入实例的进程内 capability：Growth 没有 `projectWorkflowTraceRevision` 公共 service 方法，
+也不会把 sink、registration 或 source attestation 暴露为模型工具。Delivery 或 Growth 卸载、替换
+或调用 disposer 时会撤权；旧 sink 和旧 generation 不能继续写入。
+
+Delivery 先把 revision 写进自己的 durable trace outbox，随后才异步投影并严格校验回执。暂时的
+sink 失败保留原 revision、按退避重试；重载后的有效 registration 会重放当前 revision。每条
+`WorkflowTraceRevision` 都必须携带与该 registration 完全相同的 source attestation，版本允许跳号，
+但旧版本、同版本不同内容或 digest 不一致都会拒绝。
+
+自动学习只有一个封闭来源：当前 active owner 必须直接回复一条已取得 provider message id 的普通
+Agent reply，发送精确的 `/feedback achieved`；该 reply 的原始入站正文还必须逐字命中 Delivery
+审查过的静态 catalog selector。selector 不做 trim、大小写折叠、参数解析或实体提取，生成的模板
+也完全是静态内容。只有这一组合会原子生成 content-free 的 `verified-repetition` trace；`partial`、
+`not-achieved`、未命中 catalog、preview/失败运行、手写 background intent 或无法由 durable
+Inbox/Outbox 重新证明的 reply 只会得到不可改写的本地 no-trace 回执。
+
+`/workflow save` 仍是单独的 owner-explicit 路径：它只产生带
+`owner-explicit / deidentification-unproven` attestation 的候选，绝不直接启用 Automation。一个
+owner-explicit trace 可以使候选 ready；自动路径则必须累积至少 `minRepeatedSuccesses` 个不同、当前
+有效的 `trusted + achieved` taskRef。重复投影同一 taskRef 不会抬高计数。
+
+trace source 使用导出的 `workflowArgumentShapeDigest(value)`：它只编码 JSON 类型、对象字段和数组
+成员类型集合，标量值、数组长度和顺序不会进入 fingerprint。Delivery 将可复用模板内容保留在私有
+registry，只向 Growth 投影 `templateRef/templateDigest/privacyAttestation`；Growth 不保存 raw prompt。
+这里的可信根是持有私有 sink capability 的 Host 注入 Delivery，而不是 revision 中可伪造的字符串。
+
+## 受监督实验序列
+
+Automations 实现导出的 `GrowthAutomationPort`。每个跨库动作先持久化 operation intent，再以固定
+`operationId` 调用；同一 operation 必须精确重放同一 receipt，payload 变化即拒绝。审批只能创建
+`initialState: paused` 的 Automation；通过审批后固定顺序为 replay → effect-blocked shadow → 单次
+production canary → trusted `achieved` 检查 → CAS promotion。canary 启动与查询是两个接口：
+`canaryWorkflowAutomation` 只允许一个固定 exposure operation，pending 状态只能由
+`inspectWorkflowCanary` 查询，不能重新暴露。任一拒绝、过期、证据变化、失败或恢复预算耗尽都会走
+durable rollback，而不是把 paused artifact 留作已启用。
+
+Automations 在真正创建 artifact 时才向 Delivery 的私有 resolver 解析 template reference；Growth
+始终只携带 content-free reference，不能读取或改写 owner prompt、principal 或 delivery binding。
+
+## schema v2 边界
+
+当前账本为 schema v2。v1 是曾保存 prompt-bearing template 的未发布原型，无法在保留该数据的同时
+满足 content-free 边界，因此**不做就地迁移**：启动会 fail closed。升级者必须先归档或显式删除旧
+v1 数据库，再创建新的 v2 私有账本；不得把旧模板复制进 v2 或伪造 trace 来绕过该边界。
+
+服务名为 `assistantGrowthExperiments`。`health()` 只暴露固定计数和可选错误码，不返回
+workspace、身份、证据内容或数据库路径。
+
+## 权限与数据
+
+- 文件系统：在 `databasePath` 创建 mode `0600` 的 SQLite/WAL 账本；父目录为私有目录。
+- 网络：无直接网络访问；跨系统调用只经注入的 Automation/Delivery Host service。
+- 子进程：无。
+- 凭据：不读取、不保存。
+- 浏览器：无。
+- 安装脚本：无。
+
+账本只保存工具 catalog id 和“已脱敏参数结构”的 SHA-256，不接受原始参数值。deadline
+或尝试预算耗尽后不会提升；已存在 paused/canary artifact 的失败路径进入持久 rollback
+intent。rollback 暂时不可达时保持 fail-closed 并在 health 中报告，而不是伪造终态。
+
+## 兼容性
+
+See the repository [compatibility baseline](../../docs/compatibility.md).

package/cordis.patch.yml

@@ -0,0 +1,15 @@
+- insert:
+    - id: dsh-enhanced-assistant-growth-experiments
+      name: '@dsh-enhanced/assistant-growth-experiments'
+      inject:
+        - assistantAutomations
+        - assistantDelivery
+      config:
+        databasePath: !!js dshHomePath('assistant-growth-experiments/growth.sqlite')
+        tickIntervalMs: 5000
+        minRepeatedSuccesses: 3
+        maxBatchSize: 10
+        maxExperimentDurationMs: 604800000
+        maxOperationAttempts: 8
+        retryBaseMs: 1000
+        retryMaxMs: 60000

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { AssistantGrowthExperimentsService, Config, type AssistantGrowthExperimentsConfig } from './service.js';
+import { version } from './version.js';
+export declare const name = "dsh-enhanced-assistant-growth-experiments";
+export declare const inject: string[];
+export { AssistantGrowthExperimentsService, Config, version };
+export type { AssistantGrowthExperimentsConfig };
+export * from './store.js';
+export * from './types.js';
+export declare function apply(ctx: Context, config: AssistantGrowthExperimentsConfig): void;
+export default AssistantGrowthExperimentsService;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EACL,iCAAiC,EACjC,MAAM,EACN,KAAK,gCAAgC,EACtC,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,eAAO,MAAM,IAAI,8CAA8C,CAAA;AAC/D,eAAO,MAAM,MAAM,UAAgD,CAAA;AACnE,OAAO,EAAE,iCAAiC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAA;AAC7D,YAAY,EAAE,gCAAgC,EAAE,CAAA;AAChD,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAE1B,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,gCAAgC,GAAG,IAAI,CAElF;AAED,eAAe,iCAAiC,CAAA"}

package/lib/index.js

@@ -0,0 +1,12 @@
+import { AssistantGrowthExperimentsService, Config, } from './service.js';
+import { version } from './version.js';
+export const name = 'dsh-enhanced-assistant-growth-experiments';
+export const inject = ['assistantAutomations', 'assistantDelivery'];
+export { AssistantGrowthExperimentsService, Config, version };
+export * from './store.js';
+export * from './types.js';
+export function apply(ctx, config) {
+    new AssistantGrowthExperimentsService(ctx, config);
+}
+export default AssistantGrowthExperimentsService;
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,iCAAiC,EACjC,MAAM,GAEP,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,MAAM,CAAC,MAAM,IAAI,GAAG,2CAA2C,CAAA;AAC/D,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,sBAAsB,EAAE,mBAAmB,CAAC,CAAA;AACnE,OAAO,EAAE,iCAAiC,EAAE,MAAM,EAAE,OAAO,EAAE,CAAA;AAE7D,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAE1B,MAAM,UAAU,KAAK,CAAC,GAAY,EAAE,MAAwC;IAC1E,IAAI,iCAAiC,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;AACpD,CAAC;AAED,eAAe,iCAAiC,CAAA"}

package/lib/service.d.ts

@@ -0,0 +1,53 @@
+import { Context, Service } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+import { growthPortReceiptDigest } from '@dsh-enhanced/assistant-growth-contract';
+import type { GrowthExperiment, GrowthExperimentConfig, GrowthExperimentHealth, WorkflowCandidate } from './types.js';
+export type AssistantGrowthExperimentsConfig = GrowthExperimentConfig;
+export declare const Config: Schema<GrowthExperimentConfig>;
+export type AssistantGrowthExperimentsErrorCode = 'disposed' | 'invalid-input' | 'service-unavailable';
+export declare class AssistantGrowthExperimentsError extends Error {
+    readonly code: AssistantGrowthExperimentsErrorCode;
+    constructor(code: AssistantGrowthExperimentsErrorCode, message: string);
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        assistantGrowthExperiments: AssistantGrowthExperimentsService;
+    }
+}
+export { growthPortReceiptDigest };
+export declare class AssistantGrowthExperimentsService extends Service {
+    static Config: Schema<GrowthExperimentConfig>;
+    static inject: string[];
+    private readonly config;
+    private readonly store;
+    private readonly automations;
+    private readonly now;
+    private unregisterTraceSource;
+    private timer;
+    private flight;
+    private rerunRequested;
+    private active;
+    constructor(ctx: Context, input: GrowthExperimentConfig, options?: {
+        now?: () => number;
+    });
+    health(): GrowthExperimentHealth;
+    getCandidate(id: string): WorkflowCandidate | undefined;
+    getExperiment(id: string): GrowthExperiment | undefined;
+    beginCandidateExperiment(candidateId: string): GrowthExperiment;
+    tick(): Promise<void>;
+    whenIdle(): Promise<void>;
+    private drain;
+    private process;
+    private candidateFor;
+    private artifactRequest;
+    private approval;
+    private replay;
+    private shadow;
+    private canary;
+    private promotion;
+    private rollback;
+    private defer;
+    private scheduleTick;
+    private assertActive;
+}
+//# sourceMappingURL=service.d.ts.map

package/lib/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,MAAM,MAAM,0BAA0B,CAAA;AAC7C,OAAO,EACL,uBAAuB,EAUxB,MAAM,yCAAyC,CAAA;AAEhD,OAAO,KAAK,EAIV,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,EAItB,iBAAiB,EAElB,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,gCAAgC,GAAG,sBAAsB,CAAA;AAErE,eAAO,MAAM,MAAM,EASb,MAAM,CAAC,sBAAsB,CAAC,CAAA;AAIpC,MAAM,MAAM,mCAAmC,GAC3C,UAAU,GACV,eAAe,GACf,qBAAqB,CAAA;AAEzB,qBAAa,+BAAgC,SAAQ,KAAK;IAC5C,QAAQ,CAAC,IAAI,EAAE,mCAAmC;gBAAzC,IAAI,EAAE,mCAAmC,EAAE,OAAO,EAAE,MAAM;CAIhF;AAED,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QAAG,0BAA0B,EAAE,iCAAiC,CAAA;KAAE;CACpF;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA;AAyClC,qBAAa,iCAAkC,SAAQ,OAAO;IAC5D,MAAM,CAAC,MAAM,iCAAS;IACtB,MAAM,CAAC,MAAM,WAAgD;IAE7D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwB;IAC9C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsB;IAClD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAc;IAClC,OAAO,CAAC,qBAAqB,CAA0B;IACvD,OAAO,CAAC,KAAK,CAA4C;IACzD,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,MAAM,CAAO;gBAET,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,sBAAsB,EAAE,OAAO,GAAE;QAAE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;KAAO;IAqE7F,MAAM,IAAI,sBAAsB;IAKhC,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAKvD,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAKvD,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,gBAAgB;IAUzD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAerB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;YAIjB,KAAK;YA4BL,OAAO;IAmCrB,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,eAAe;YAIT,QAAQ;YAiDR,MAAM;YAcN,MAAM;YAcN,MAAM;YA+BN,SAAS;YAgBT,QAAQ;IAStB,OAAO,CAAC,KAAK;IAoBb,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,YAAY;CAGrB"}

package/lib/service.js

@@ -0,0 +1,422 @@
+import { isAbsolute } from 'node:path';
+import { Context, Service } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+import { growthPortReceiptDigest, validateGrowthAutomationApprovalReceipt, validateGrowthAutomationProposalReceipt, validateGrowthCanaryInspectionReceipt, validateGrowthCanaryReceipt, validateGrowthPromotionReceipt, validateGrowthReplayReceipt, validateGrowthRollbackReceipt, validateGrowthShadowReceipt, validateGrowthWorkflowTraceSourceRegistration, } from '@dsh-enhanced/assistant-growth-contract';
+import { GrowthExperimentsStore, GrowthExperimentsStoreError } from './store.js';
+export const Config = Schema.object({
+    databasePath: Schema.string().required(),
+    tickIntervalMs: Schema.number().step(1).min(0).max(86_400_000).default(5_000),
+    minRepeatedSuccesses: Schema.number().step(1).min(2).max(100).default(3),
+    maxBatchSize: Schema.number().step(1).min(1).max(1_000).default(10),
+    maxExperimentDurationMs: Schema.number().step(1).min(1_000).max(31_536_000_000).default(604_800_000),
+    maxOperationAttempts: Schema.number().step(1).min(1).max(100).default(8),
+    retryBaseMs: Schema.number().step(1).min(1).max(86_400_000).default(1_000),
+    retryMaxMs: Schema.number().step(1).min(1).max(86_400_000).default(60_000),
+});
+export class AssistantGrowthExperimentsError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'AssistantGrowthExperimentsError';
+    }
+}
+export { growthPortReceiptDigest };
+function identity(experiment) {
+    return Object.freeze({
+        contractVersion: 1,
+        operationId: experiment.operationId,
+        experimentId: experiment.id,
+        candidateId: experiment.candidateId,
+        candidateRevision: experiment.candidateRevision,
+        candidateDigest: experiment.candidateDigest,
+    });
+}
+function artifact(experiment) {
+    if (experiment.artifactId === undefined || experiment.artifactVersion === undefined
+        || experiment.artifactDigest === undefined) {
+        throw new AssistantGrowthExperimentsError('invalid-input', 'experiment has no paused artifact');
+    }
+    return Object.freeze({
+        artifactId: experiment.artifactId,
+        artifactVersion: experiment.artifactVersion,
+        artifactDigest: experiment.artifactDigest,
+    });
+}
+function requireMethod(value, method, provider) {
+    if ((typeof value !== 'object' && typeof value !== 'function') || value === null
+        || typeof value[method] !== 'function') {
+        throw new AssistantGrowthExperimentsError('service-unavailable', `${provider}.${method} is required`);
+    }
+}
+function stableErrorCode(error) {
+    const value = ((typeof error === 'object' || typeof error === 'function') && error !== null
+        && typeof error.code === 'string')
+        ? error.code
+        : 'operation-failed';
+    const normalized = value.normalize('NFC').trim().toLowerCase();
+    return /^[a-z\d][a-z\d.-]{0,63}$/u.test(normalized) ? normalized : 'operation-failed';
+}
+export class AssistantGrowthExperimentsService extends Service {
+    static Config = Config;
+    static inject = ['assistantAutomations', 'assistantDelivery'];
+    config;
+    store;
+    automations;
+    now;
+    unregisterTraceSource;
+    timer;
+    flight;
+    rerunRequested = false;
+    active = true;
+    constructor(ctx, input, options = {}) {
+        super(ctx, 'assistantGrowthExperiments');
+        let config;
+        try {
+            config = Config(input);
+        }
+        catch (error) {
+            throw new AssistantGrowthExperimentsError('invalid-input', `invalid configuration: ${String(error)}`);
+        }
+        if (!isAbsolute(config.databasePath) || config.retryMaxMs < config.retryBaseMs) {
+            throw new AssistantGrowthExperimentsError('invalid-input', 'database path or retry bounds are invalid');
+        }
+        const automations = ctx.get('assistantAutomations');
+        for (const method of ['requestWorkflowAutomation', 'settleWorkflowAutomation',
+            'replayWorkflowAutomation', 'shadowWorkflowAutomation', 'canaryWorkflowAutomation',
+            'inspectWorkflowCanary', 'promoteWorkflowAutomation', 'rollbackWorkflowAutomation']) {
+            requireMethod(automations, method, 'assistantAutomations');
+        }
+        const delivery = ctx.get('assistantDelivery');
+        requireMethod(delivery, 'registerWorkflowTraceSink', 'assistantDelivery');
+        this.config = config;
+        this.now = options.now ?? Date.now;
+        this.automations = automations;
+        this.store = new GrowthExperimentsStore({
+            path: config.databasePath,
+            minRepeatedSuccesses: config.minRepeatedSuccesses,
+            now: this.now,
+        });
+        let registeredSource;
+        try {
+            const registration = delivery.registerWorkflowTraceSink({
+                contractVersion: 1,
+                sink: Object.freeze({
+                    projectWorkflowTraceRevision: (revision) => {
+                        if (registeredSource === undefined
+                            || revision.source.sourceId !== registeredSource.sourceId
+                            || revision.source.generation !== registeredSource.generation
+                            || revision.source.authorityDigest !== registeredSource.authorityDigest) {
+                            throw new AssistantGrowthExperimentsError('invalid-input', 'workflow trace does not match the authenticated Delivery registration');
+                        }
+                        const receipt = this.store.projectWorkflowTraceRevision(revision);
+                        this.scheduleTick();
+                        return receipt;
+                    },
+                }),
+            });
+            const validatedRegistration = validateGrowthWorkflowTraceSourceRegistration(registration);
+            registeredSource = Object.freeze({ sourceId: validatedRegistration.sourceId,
+                generation: validatedRegistration.generation, authorityDigest: validatedRegistration.authorityDigest });
+            this.unregisterTraceSource = () => registration.dispose();
+        }
+        catch (error) {
+            this.store.close();
+            throw error;
+        }
+        if (config.tickIntervalMs > 0) {
+            this.timer = setInterval(() => { this.scheduleTick(); }, config.tickIntervalMs);
+            this.timer.unref?.();
+        }
+        ctx.effect(() => async () => {
+            this.active = false;
+            if (this.timer !== undefined)
+                clearInterval(this.timer);
+            this.unregisterTraceSource?.();
+            await this.flight;
+            this.store.close();
+        }, 'assistant-growth-experiments.runtime');
+    }
+    health() {
+        this.assertActive();
+        return this.store.health();
+    }
+    getCandidate(id) {
+        this.assertActive();
+        return this.store.getCandidate(id);
+    }
+    getExperiment(id) {
+        this.assertActive();
+        return this.store.getExperiment(id);
+    }
+    beginCandidateExperiment(candidateId) {
+        this.assertActive();
+        const value = this.store.beginReadyExperiment({
+            candidateId,
+            maxDurationMs: this.config.maxExperimentDurationMs,
+        });
+        this.scheduleTick();
+        return value;
+    }
+    async tick() {
+        this.assertActive();
+        if (this.flight !== undefined) {
+            this.rerunRequested = true;
+            return this.flight;
+        }
+        this.flight = (async () => {
+            do {
+                this.rerunRequested = false;
+                await this.drain();
+            } while (this.rerunRequested && this.active);
+        })().finally(() => { this.flight = undefined; });
+        return this.flight;
+    }
+    async whenIdle() {
+        await this.flight;
+    }
+    async drain() {
+        let hadError = false;
+        const ready = this.store.listCandidates({ state: 'ready', limit: this.config.maxBatchSize });
+        for (const candidate of ready) {
+            try {
+                this.store.beginReadyExperiment({
+                    candidateId: candidate.id,
+                    maxDurationMs: this.config.maxExperimentDurationMs,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof GrowthExperimentsStoreError && error.code === 'version-conflict'))
+                    throw error;
+            }
+        }
+        const rows = this.store.listRunnableExperiments(this.now(), this.config.maxBatchSize);
+        for (const row of rows) {
+            if (!this.active)
+                return;
+            try {
+                await this.process(row);
+            }
+            catch (error) {
+                if (error instanceof GrowthExperimentsStoreError && error.code === 'version-conflict')
+                    continue;
+                hadError = true;
+                this.store.recordError(stableErrorCode(error));
+                this.defer(row.id, error);
+            }
+        }
+        if (!hadError)
+            this.store.recordError(undefined);
+    }
+    async process(snapshot) {
+        let current = this.store.getExperiment(snapshot.id);
+        if (current === undefined || current.version !== snapshot.version)
+            return;
+        if (current.state === 'approval-pending') {
+            if (this.now() > current.deadlineAt) {
+                this.store.transitionExperiment({ experimentId: current.id, expectedVersion: current.version,
+                    expectedState: current.state, state: 'expired', terminalCode: 'deadline-exceeded' });
+                return;
+            }
+            current = this.store.transitionExperiment({
+                experimentId: current.id, expectedVersion: current.version, expectedState: current.state,
+                state: 'approval-requesting', operationKind: 'approval-settlement',
+                operationId: `${current.id}:approval-settlement:${current.version + 1}`,
+                ...(current.proposalId === undefined ? {} : { proposalId: current.proposalId }),
+            });
+        }
+        if (this.now() > current.deadlineAt && current.state !== 'approval-requesting'
+            && current.state !== 'rollback-pending') {
+            this.store.requestRollback({ experimentId: current.id, expectedVersion: current.version,
+                code: 'deadline-exceeded' });
+            return;
+        }
+        switch (current.operationKind) {
+            case 'approval-proposal':
+            case 'approval-settlement':
+                await this.approval(current);
+                return;
+            case 'replay':
+                await this.replay(current);
+                return;
+            case 'shadow':
+                await this.shadow(current);
+                return;
+            case 'canary':
+                await this.canary(current, false);
+                return;
+            case 'canary-inspection':
+                await this.canary(current, true);
+                return;
+            case 'promotion':
+                await this.promotion(current);
+                return;
+            case 'rollback':
+                await this.rollback(current);
+                return;
+            default: throw new AssistantGrowthExperimentsError('invalid-input', 'active experiment lacks a durable operation intent');
+        }
+    }
+    candidateFor(experiment) {
+        const value = this.store.getCandidate(experiment.candidateId);
+        if (value === undefined || value.revision !== experiment.candidateRevision
+            || value.evidenceDigest !== experiment.candidateDigest || value.state !== 'running') {
+            throw new GrowthExperimentsStoreError('version-conflict', 'candidate evidence changed');
+        }
+        return value;
+    }
+    artifactRequest(experiment) {
+        return Object.freeze({ ...identity(experiment), ...artifact(experiment) });
+    }
+    async approval(experiment) {
+        const candidate = this.store.getCandidate(experiment.candidateId);
+        const stale = candidate === undefined || candidate.revision !== experiment.candidateRevision
+            || candidate.evidenceDigest !== experiment.candidateDigest || candidate.state !== 'running'
+            || experiment.terminalCode === 'evidence-superseded';
+        const raw = experiment.operationKind === 'approval-proposal'
+            ? await this.automations.requestWorkflowAutomation(Object.freeze({
+                ...identity(experiment),
+                initialState: 'paused',
+                scope: experiment.candidateSnapshot.scope,
+                ownerBindingId: experiment.candidateSnapshot.ownerBindingId,
+                evidenceDigest: experiment.candidateDigest,
+                evidenceCount: experiment.candidateSnapshot.evidenceCount,
+                template: experiment.candidateSnapshot.template,
+                steps: experiment.candidateSnapshot.steps,
+                deadlineAt: experiment.deadlineAt,
+            }))
+            : await this.automations.settleWorkflowAutomation(Object.freeze({
+                ...identity(experiment), proposalId: experiment.proposalId,
+            }));
+        const receipt = experiment.operationKind === 'approval-proposal'
+            ? validateGrowthAutomationProposalReceipt(raw, identity(experiment))
+            : validateGrowthAutomationApprovalReceipt(raw, identity(experiment));
+        if (receipt.outcome === 'approved-paused') {
+            const next = stale || this.now() > experiment.deadlineAt ? 'rollback-pending' : 'replay-pending';
+            this.store.transitionExperiment({
+                experimentId: experiment.id, expectedVersion: experiment.version, expectedState: experiment.state,
+                state: next, operationKind: next === 'rollback-pending' ? 'rollback' : 'replay',
+                operationId: `${experiment.id}:${next === 'rollback-pending' ? 'rollback' : 'replay'}`,
+                proposalId: receipt.proposalId,
+                artifact: { id: receipt.artifactId, version: receipt.artifactVersion, digest: receipt.artifactDigest },
+                ...(stale ? { terminalCode: 'evidence-superseded' } : {}),
+            });
+            return;
+        }
+        if (receipt.outcome === 'approval-pending' && !stale && this.now() <= experiment.deadlineAt) {
+            this.store.transitionExperiment({ experimentId: experiment.id, expectedVersion: experiment.version,
+                expectedState: experiment.state, state: 'approval-pending', proposalId: receipt.proposalId,
+                nextAttemptAt: this.now() + this.config.retryBaseMs });
+            return;
+        }
+        const state = stale ? 'conflicted' : receipt.outcome === 'approval-pending' || receipt.outcome === 'expired'
+            ? 'expired' : receipt.outcome;
+        this.store.transitionExperiment({ experimentId: experiment.id, expectedVersion: experiment.version,
+            expectedState: experiment.state, state,
+            ...(receipt.proposalId === undefined ? {} : { proposalId: receipt.proposalId }),
+            terminalCode: stale ? 'evidence-superseded' : `approval-${receipt.outcome}` });
+    }
+    async replay(experiment) {
+        this.candidateFor(experiment);
+        const request = this.artifactRequest(experiment);
+        const receipt = validateGrowthReplayReceipt(await this.automations.replayWorkflowAutomation(request), request);
+        this.store.transitionExperiment({ experimentId: experiment.id, expectedVersion: experiment.version,
+            expectedState: experiment.state, state: receipt.outcome === 'passed' ? 'shadow-pending' : 'rollback-pending',
+            operationKind: receipt.outcome === 'passed' ? 'shadow' : 'rollback',
+            operationId: `${experiment.id}:${receipt.outcome === 'passed' ? 'shadow' : 'rollback'}`,
+            ...(receipt.outcome === 'failed' ? { terminalCode: 'replay-failed' } : {}),
+        });
+    }
+    async shadow(experiment) {
+        this.candidateFor(experiment);
+        const request = this.artifactRequest(experiment);
+        const receipt = validateGrowthShadowReceipt(await this.automations.shadowWorkflowAutomation(request), request);
+        this.store.transitionExperiment({ experimentId: experiment.id, expectedVersion: experiment.version,
+            expectedState: experiment.state, state: receipt.outcome === 'passed' ? 'canary-pending' : 'rollback-pending',
+            operationKind: receipt.outcome === 'passed' ? 'canary' : 'rollback',
+            operationId: `${experiment.id}:${receipt.outcome === 'passed' ? 'canary' : 'rollback'}`,
+            ...(receipt.outcome === 'failed' ? { terminalCode: 'shadow-failed' } : {}),
+        });
+    }
+    async canary(experiment, inspection) {
+        this.candidateFor(experiment);
+        let current = experiment;
+        if (!inspection && current.canaryExposureCount === 0) {
+            current = this.store.markCanaryIssued({ experimentId: current.id, expectedVersion: current.version });
+        }
+        const request = this.artifactRequest(current);
+        const inspectionRequest = Object.freeze({
+            ...request, exposureOperationId: `${current.id}:canary`,
+        });
+        const raw = inspection
+            ? await this.automations.inspectWorkflowCanary(inspectionRequest)
+            : await this.automations.canaryWorkflowAutomation(request);
+        const receipt = inspection
+            ? validateGrowthCanaryInspectionReceipt(raw, inspectionRequest)
+            : validateGrowthCanaryReceipt(raw, request);
+        if (receipt.outcome === 'pending') {
+            this.store.transitionExperiment({ experimentId: current.id, expectedVersion: current.version,
+                expectedState: current.state, state: 'canary-pending', operationKind: 'canary-inspection',
+                operationId: `${current.id}:canary-inspection:${current.version + 1}`,
+                canaryExposureCount: 1, nextAttemptAt: this.now() + this.config.retryBaseMs });
+            return;
+        }
+        this.store.transitionExperiment({ experimentId: current.id, expectedVersion: current.version,
+            expectedState: current.state, state: receipt.outcome === 'passed' ? 'promotion-pending' : 'rollback-pending',
+            operationKind: receipt.outcome === 'passed' ? 'promotion' : 'rollback',
+            operationId: `${current.id}:${receipt.outcome === 'passed' ? 'promotion' : 'rollback'}`,
+            ...(receipt.outcome === 'failed' ? { terminalCode: 'canary-failed' } : {}),
+        });
+    }
+    async promotion(experiment) {
+        this.candidateFor(experiment);
+        const request = this.artifactRequest(experiment);
+        const receipt = validateGrowthPromotionReceipt(await this.automations.promoteWorkflowAutomation(request), request);
+        this.store.transitionExperiment({ experimentId: experiment.id, expectedVersion: experiment.version,
+            expectedState: experiment.state, state: 'promoted', terminalCode: 'trusted-canary-promoted',
+            artifact: {
+                id: experiment.artifactId,
+                version: receipt.resultingArtifactVersion,
+                digest: receipt.resultingArtifactDigest,
+            },
+        });
+    }
+    async rollback(experiment) {
+        const request = this.artifactRequest(experiment);
+        validateGrowthRollbackReceipt(await this.automations.rollbackWorkflowAutomation(request), request);
+        this.store.transitionExperiment({ experimentId: experiment.id, expectedVersion: experiment.version,
+            expectedState: experiment.state, state: 'rolled-back', terminalCode: experiment.terminalCode ?? 'rolled-back' });
+    }
+    defer(experimentId, error) {
+        const current = this.store.getExperiment(experimentId);
+        if (current === undefined || ['conflicted', 'expired', 'promoted', 'rejected', 'rolled-back']
+            .includes(current.state))
+            return;
+        const attempts = current.attemptCount + 1;
+        if (attempts >= this.config.maxOperationAttempts && current.state !== 'approval-requesting') {
+            if (current.state === 'rollback-pending') {
+                this.store.recordOperationFailure({ experimentId: current.id, expectedVersion: current.version,
+                    code: 'rollback-retry-budget-exhausted', nextAttemptAt: this.now() + this.config.retryMaxMs });
+            }
+            else {
+                this.store.requestRollback({ experimentId: current.id, expectedVersion: current.version,
+                    code: 'operation-retry-budget-exhausted' });
+            }
+            return;
+        }
+        const delay = Math.min(this.config.retryMaxMs, this.config.retryBaseMs * (2 ** Math.min(attempts - 1, 20)));
+        this.store.recordOperationFailure({ experimentId: current.id, expectedVersion: current.version,
+            code: stableErrorCode(error), nextAttemptAt: this.now() + delay });
+    }
+    scheduleTick() {
+        void this.tick().catch(error => {
+            if (this.active)
+                this.store.recordError(stableErrorCode(error));
+        });
+    }
+    assertActive() {
+        if (!this.active)
+            throw new AssistantGrowthExperimentsError('disposed', 'service is disposed');
+    }
+}
+//# sourceMappingURL=service.js.map