@atolis-hq/wake 0.4.15 → 0.4.17

package/dist/src/bootstrap/config/root-schema.d.ts

@@ -140,6 +140,11 @@ declare const hostConfigSchema: z.ZodDefault<z.ZodObject<{
     selfUpdate: z.ZodDefault<z.ZodObject<{
         drainTimeoutMs: z.ZodDefault<z.ZodNumber>;
         cancellationTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        npm: z.ZodDefault<z.ZodObject<{
+            package: z.ZodDefault<z.ZodString>;
+            distTag: z.ZodDefault<z.ZodString>;
+            registry: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>>;
 export declare const rootConfigSchema: z.ZodObject<{
@@ -340,13 +345,26 @@ export declare const rootConfigSchema: z.ZodObject<{
     integrations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodObject<{
         provider: z.ZodOptional<z.ZodString>;
         enabled: z.ZodDefault<z.ZodBoolean>;
+        conversation: z.ZodOptional<z.ZodObject<{
+            capabilities: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                "review-surface": "review-surface";
+                "chat-surface": "chat-surface";
+                "operator-surface": "operator-surface";
+            }>>>;
+        }, z.core.$strict>>;
     }, z.core.$loose>, z.ZodTransform<{
         enabled: boolean;
         provider?: string | undefined;
+        conversation?: {
+            capabilities: readonly ("review-surface" | "chat-surface" | "operator-surface")[];
+        } | undefined;
     }, {
         [x: string]: unknown;
         enabled: boolean;
         provider?: string | undefined;
+        conversation?: {
+            capabilities: readonly ("review-surface" | "chat-surface" | "operator-surface")[];
+        } | undefined;
     }>>>>;
     surfaces: z.ZodPipe<z.ZodDefault<z.ZodObject<{
         api: z.ZodDefault<z.ZodObject<{
@@ -423,6 +441,11 @@ export declare const rootConfigSchema: z.ZodObject<{
         selfUpdate: z.ZodDefault<z.ZodObject<{
             drainTimeoutMs: z.ZodDefault<z.ZodNumber>;
             cancellationTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            npm: z.ZodDefault<z.ZodObject<{
+                package: z.ZodDefault<z.ZodString>;
+                distTag: z.ZodDefault<z.ZodString>;
+                registry: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;

package/dist/src/bootstrap/config/root-schema.js

@@ -35,7 +35,11 @@ const orchestrationConfigSchema = z
         });
     }
 })
-    .default({ workflows: {}, workflowSelectors: [], default: 'default' });
+    .default({
+    workflows: {},
+    workflowSelectors: [],
+    default: 'default',
+});
 const transcriptsConfigSchema = z
     .object({
     enabled: z.boolean().default(false),
@@ -88,9 +92,21 @@ const hostConfigSchema = z
         .object({
         drainTimeoutMs: z.number().int().positive().default(30_000),
         cancellationTimeoutMs: z.number().int().positive().default(30_000),
+        npm: z
+            .object({
+            package: z.string().trim().min(1).default('@atolis-hq/wake'),
+            distTag: z.string().trim().min(1).default('latest'),
+            registry: z.string().url().optional(),
+        })
+            .strict()
+            .default({ package: '@atolis-hq/wake', distTag: 'latest' }),
     })
         .strict()
-        .default({ drainTimeoutMs: 30_000, cancellationTimeoutMs: 30_000 }),
+        .default({
+        drainTimeoutMs: 30_000,
+        cancellationTimeoutMs: 30_000,
+        npm: { package: '@atolis-hq/wake', distTag: 'latest' },
+    }),
 })
     .strict()
     .default({
@@ -104,7 +120,11 @@ const hostConfigSchema = z
         extraMounts: [],
     },
     development: {},
-    selfUpdate: { drainTimeoutMs: 30_000, cancellationTimeoutMs: 30_000 },
+    selfUpdate: {
+        drainTimeoutMs: 30_000,
+        cancellationTimeoutMs: 30_000,
+        npm: { package: '@atolis-hq/wake', distTag: 'latest' },
+    },
 })
     .superRefine((value, context) => {
     if (value.development.mode === 'source' && value.development.repoRoot === undefined)

package/dist/src/bootstrap/index.d.ts

@@ -24,4 +24,5 @@ export * from './update-ledger.js';
 export * from './update-maintenance-lease.js';
 export * from './self-update-application.js';
 export * from './source-update-port.js';
+export * from './npm-update-port.js';
 export * from './version.js';

package/dist/src/bootstrap/index.js

@@ -26,4 +26,5 @@ export * from './update-ledger.js';
 export * from './update-maintenance-lease.js';
 export * from './self-update-application.js';
 export * from './source-update-port.js';
+export * from './npm-update-port.js';
 export * from './version.js';

package/dist/src/bootstrap/npm-update-port.d.ts

@@ -0,0 +1,11 @@
+import type { SourceUpdatePort } from './self-update-application.js';
+export interface NpmUpdateProcess {
+    execute(command: string, args: readonly string[]): Promise<string>;
+}
+/** Resolves immutable published package versions. Installation is performed by the rollout. */
+export declare function createNpmUpdatePort(input: {
+    readonly packageName: string;
+    readonly distTag?: string;
+    readonly registry?: string;
+    readonly execute?: NpmUpdateProcess['execute'];
+}): SourceUpdatePort;

package/dist/src/bootstrap/npm-update-port.js

@@ -0,0 +1,45 @@
+import { execFile as nodeExecFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFile = promisify(nodeExecFile);
+/** Resolves immutable published package versions. Installation is performed by the rollout. */
+export function createNpmUpdatePort(input) {
+    const execute = input.execute ?? runProcess;
+    const distTag = input.distTag ?? 'latest';
+    const registry = input.registry === undefined ? [] : [`--registry=${input.registry}`];
+    return {
+        isClean: async () => true,
+        async latestTag() {
+            const resolved = await resolveVersion();
+            if (resolved === undefined)
+                throw new Error(`No npm version is available for ${input.packageName}`);
+            return resolved;
+        },
+        async candidateTags() {
+            const resolved = await resolveVersion();
+            return resolved === undefined ? [] : [resolved];
+        },
+        // The Docker rollout installs this exact version. Keeping this side-effect-free means
+        // the updater never overwrites the CLI process which is coordinating the update.
+        checkout: async () => { },
+        healthy: async () => true,
+    };
+    async function resolveVersion() {
+        const output = await execute('npm', [
+            'view',
+            `${input.packageName}@${distTag}`,
+            'version',
+            '--json',
+            ...registry,
+        ]);
+        const parsed = JSON.parse(output);
+        const value = Array.isArray(parsed) ? parsed.at(0) : parsed;
+        if (typeof value !== 'string' ||
+            !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u.test(value))
+            throw new Error(`npm returned an invalid version for ${input.packageName}@${distTag}`);
+        return value;
+    }
+}
+async function runProcess(command, args) {
+    const result = await execFile(command, args, { encoding: 'utf8' });
+    return result.stdout;
+}

package/dist/src/bootstrap/self-update-application.js

@@ -10,9 +10,8 @@ export function createSelfUpdateApplication(input) {
         async updateLatest(force = false) {
             const candidates = await input.source.candidateTags();
             const [latestCandidate] = candidates;
-            if (latestCandidate === undefined) {
-                throw new Error('No source version tags available');
-            }
+            if (latestCandidate === undefined)
+                throw new Error('No update versions are available');
             for (const tag of candidates) {
                 if (!force && (await input.ledger.isBad(tag))) {
                     continue;

package/dist/src/bootstrap/surface-api-work-applications.js

@@ -2,7 +2,7 @@ import { correlationId, EventActorKind } from '@atolis-hq/eventing';
 import { pullRequestProjection } from '../activities/index.js';
 import { conversationIdForWorkItem, ConversationOriginKind, } from '../conversations/index.js';
 import { executionProjection, runsByWorkflowInstanceProjection, } from '../execution/index.js';
-import { ApprovalAuthorityKind, GroupBudgetExtensionIneligibleError, isGroupBudgetExtensionEligible, OperatorRetryIneligibleError, orchestrationProjection, selectOperatorRetryTarget, workflowsByWorkItemProjection, } from '../orchestration/index.js';
+import { ApprovalAuthorityKind, ConversationSurfaceCapability, GroupBudgetExtensionIneligibleError, isGroupBudgetExtensionEligible, OperatorRetryIneligibleError, orchestrationProjection, selectOperatorRetryTarget, workflowsByWorkItemProjection, } from '../orchestration/index.js';
 import { workCorrelationsProjection, } from '../resources/index.js';
 import { ApiCommandStatus, fromWorkItemKey, presentResource, presentRun, presentWorkflowInstance, presentWorkItem, } from '../surfaces/index.js';
 import { workItemId, WorkStatus } from '../work/index.js';
@@ -134,7 +134,18 @@ export function createSurfaceWorkApplications(root, now) {
                         body: command.body,
                         origin: { kind: ConversationOriginKind.ControlPlane, actorId: context.actor.id },
                     }, context);
-                    await resumeAgentStages(root, id, context);
+                    const dispatch = root.orchestration
+                        .applyConversationCommand;
+                    const applied = dispatch === undefined
+                        ? false
+                        : await dispatch.call(root.orchestration, id, {
+                            body: command.body,
+                            actorId: context.actor.id,
+                            capabilities: [ConversationSurfaceCapability.Operator],
+                            authorized: true,
+                        }, context);
+                    if (!applied)
+                        await resumeAgentStages(root, id, context);
                     return accepted(command.idempotencyKey, now());
                 },
             }

package/dist/src/bootstrap/surface-cli-applications.js

@@ -12,6 +12,7 @@ import { ResourceCorrelationRole, resourceId } from '../resources/index.js';
 import { DockerProcessError, createApiDispatcher, createLoggedDockerCli, createPackagedAssetSource, createPairingGrant, createProcessLogSink, createSandboxDockerPort, createSurfaceHttpServer, drainProcessOutput, loadOrCreateCredentials, redeemPairingGrant, replaceAccessKey, runDoctor, runSandbox, runSandboxEntrypoint, runSandboxSetup, runSelfUpdateLatestLoop, runTargetSmoke, verifyResidentStart, waitForActiveRuns, waitForever, } from '../surfaces/index.js';
 import { WorkStreamKind, workItemId } from '../work/index.js';
 import { loadConfig } from './config/load-config.js';
+import { createNpmUpdatePort } from './npm-update-port.js';
 import { runtimeProjectionDefinitions } from './projection-runtime.js';
 import { createRunnerRegistry } from './runner-registry.js';
 import { createOneShotRunnerAdvance, createResidentRunnerAdvance, withFinalProjectionCatchUp, } from './runner-tick-adapter.js';
@@ -315,7 +316,7 @@ function sandboxDockerOptions(root, overrides) {
         wakeRoot: root.paths.wakeRoot,
         containerHomeRoot: root.paths.containerHomeRoot,
         image: overrides?.image ?? root.config.host.sandbox.image,
-        development: root.config.host.development,
+        development: overrides?.development ?? root.config.host.development,
         containerName: root.config.host.sandbox.containerName,
         ...(root.config.surfaces.api.enabled ? { publishedPort: root.config.surfaces.api.port } : {}),
         wakeMountPath: root.config.host.sandbox.wakeMountPath,
@@ -324,7 +325,9 @@ function sandboxDockerOptions(root, overrides) {
         startEnabled: root.config.host.sandbox.start.enabled,
         ...(process.env.WAKE_MEMORY_PROFILE === 'runner' ? { memoryProfile: 'runner' } : {}),
         inspect: createDockerInspection(root.paths.wakeRoot),
-        resolveBuildVersion: () => resolveSandboxBuildVersion(root),
+        resolveBuildVersion: async () => overrides?.buildVersion === undefined
+            ? resolveSandboxBuildVersion(root)
+            : overrides.buildVersion,
     };
 }
 function createSandboxDocker(root, overrides) {
@@ -408,11 +411,13 @@ function createSandboxRuntimeApplications(root) {
  * resident `wake start` process actually came back up. Reused for both the
  * forward deploy and a same-shaped rollback to a previously-built tag.
  */
-async function deploySandboxTag(root, docker, tag, image) {
-    const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image }));
+async function deploySandboxTag(root, docker, tag, image, overrides) {
+    const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image, ...overrides }));
     await port.build();
     await port.update();
-    const wakeInvocation = sandboxWakeInvocation(root);
+    const wakeInvocation = overrides?.development?.mode === 'source'
+        ? ['node', '/app/dist/src/main.js']
+        : sandboxWakeInvocation(root);
     await verifyResidentStart(docker, root.config.host.sandbox.containerName, [...wakeInvocation, 'start', '--wake-root', '/wake'].join(' '));
     await port.exec([
         ...wakeInvocation,
@@ -421,10 +426,12 @@ async function deploySandboxTag(root, docker, tag, image) {
         `/tmp/wake-self-update-healthcheck-${tag}`,
     ]);
 }
-async function rollbackSandboxTag(root, docker, image) {
+async function rollbackSandboxTag(root, docker, image, development) {
     const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image }));
     await port.update();
-    const wakeInvocation = sandboxWakeInvocation(root);
+    const wakeInvocation = development?.mode === 'source'
+        ? ['node', '/app/dist/src/main.js']
+        : sandboxWakeInvocation(root);
     await verifyResidentStart(docker, root.config.host.sandbox.containerName, [...wakeInvocation, 'start', '--wake-root', '/wake'].join(' '));
 }
 function createOperationalApplications(root) {
@@ -450,31 +457,56 @@ function createOperationalApplications(root) {
         sandboxEntrypoint: async () => {
             await runSandboxEntrypoint(createSandboxEntrypointDependencies(root));
         },
+        // eslint-disable-next-line complexity -- update source and loop options are validated at this CLI boundary.
         selfUpdate: async (arguments_) => {
-            if (root.config.host.development.mode !== 'source')
-                throw new Error('wake self-update requires host.development.mode: source');
-            const repoRoot = root.config.host.development.repoRoot;
-            if (repoRoot === undefined)
+            const sourceRoot = optionalOperationalOption(arguments_, '--source');
+            const configuredSource = root.config.host.development.mode === 'source';
+            const repoRoot = sourceRoot ?? root.config.host.development.repoRoot;
+            if (sourceRoot !== undefined && root.config.host.development.mode === 'source')
+                throw new Error('wake self-update --source cannot override source-mode configuration');
+            if (configuredSource && repoRoot === undefined)
                 throw new Error('wake self-update requires host.development.repoRoot');
             const tag = optionalOperationalOption(arguments_, '--tag');
+            const version = optionalOperationalOption(arguments_, '--version');
+            if (tag !== undefined && version !== undefined)
+                throw new Error('wake self-update accepts only one of --tag or --version');
+            if (version !== undefined && (configuredSource || sourceRoot !== undefined))
+                throw new Error('wake self-update --version is only valid for npm updates');
+            const useSource = configuredSource || sourceRoot !== undefined;
+            const updatePort = useSource
+                ? createSourceUpdatePort({ repoRoot: repoRoot })
+                : createNpmUpdatePort({
+                    packageName: root.config.host.selfUpdate.npm.package,
+                    distTag: root.config.host.selfUpdate.npm.distTag,
+                    ...(root.config.host.selfUpdate.npm.registry === undefined
+                        ? {}
+                        : { registry: root.config.host.selfUpdate.npm.registry }),
+                });
+            const updateTag = tag ?? version;
+            const updateDevelopment = useSource
+                ? { mode: 'source', repoRoot: repoRoot }
+                : { mode: 'packaged' };
             const dockerCli = createDockerCliForRoot(root);
             const imageRepository = root.config.host.sandbox.imageRepository;
             const failureLog = createSelfUpdateFailureLog(root.paths.wakeRoot);
             const application = createSelfUpdateApplication({
                 ledger: createUpdateLedger(root.paths.wakeRoot),
-                source: createSourceUpdatePort({ repoRoot }),
+                source: updatePort,
                 rollout: {
                     async deploy(deployTag) {
                         await waitForActiveRuns({
                             activeRunIds: () => activeExecutionRunIds(root),
                             sleep: async (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
                         });
-                        await deploySandboxTag(root, dockerCli, deployTag, `${imageRepository}:${deployTag}`);
+                        await deploySandboxTag(root, dockerCli, deployTag, `${imageRepository}:${deployTag}`, {
+                            development: updateDevelopment,
+                            buildVersion: deployTag,
+                        });
                         // A later deploy succeeding after a prior rollback clears the stale warning.
                         await failureLog.clear();
                     },
                     async rollback(rollbackTag) {
-                        await rollbackSandboxTag(root, dockerCli, `${imageRepository}:${rollbackTag}`);
+                        await rollbackSandboxTag(root, dockerCli, `${imageRepository}:${rollbackTag}`, updateDevelopment);
                     },
                     recordFailure: (failedTag, error) => failureLog.record(failedTag, error),
                 },
@@ -485,12 +517,12 @@ function createOperationalApplications(root) {
             const force = arguments_.includes('--force');
             if (arguments_.includes('--loop')) {
                 const intervalMs = selfUpdateLoopInterval(arguments_);
-                if (tag !== undefined)
-                    return runSelfUpdateLatestLoop(async () => application.update(tag, force), () => delay(intervalMs));
+                if (updateTag !== undefined)
+                    return runSelfUpdateLatestLoop(async () => application.update(updateTag, force), () => delay(intervalMs));
                 return runSelfUpdateLatestLoop(async () => application.updateLatest(force), () => delay(intervalMs));
             }
-            if (tag !== undefined)
-                return { tag, updated: await application.update(tag, force) };
+            if (updateTag !== undefined)
+                return { tag: updateTag, updated: await application.update(updateTag, force) };
             return application.updateLatest(force);
         },
         smoke: async () => runTargetSmoke(createRunnerRegistry(root.config.execution, root.fakeScenarios), root.config.execution.defaultRunnerPool, new AbortController().signal),

package/dist/src/bootstrap/version.js

@@ -124,6 +124,6 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "v0.4.15";
+export const wakeVersion = "v0.4.17";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

package/dist/src/integrations/contracts/config.d.ts

@@ -2,12 +2,25 @@ import { z } from 'zod';
 export declare const integrationsConfigSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodObject<{
     provider: z.ZodOptional<z.ZodString>;
     enabled: z.ZodDefault<z.ZodBoolean>;
+    conversation: z.ZodOptional<z.ZodObject<{
+        capabilities: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            "review-surface": "review-surface";
+            "chat-surface": "chat-surface";
+            "operator-surface": "operator-surface";
+        }>>>;
+    }, z.core.$strict>>;
 }, z.core.$loose>, z.ZodTransform<{
     enabled: boolean;
     provider?: string | undefined;
+    conversation?: {
+        capabilities: readonly ("review-surface" | "chat-surface" | "operator-surface")[];
+    } | undefined;
 }, {
     [x: string]: unknown;
     enabled: boolean;
     provider?: string | undefined;
+    conversation?: {
+        capabilities: readonly ("review-surface" | "chat-surface" | "operator-surface")[];
+    } | undefined;
 }>>>>;
 export type IntegrationsConfig = z.infer<typeof integrationsConfigSchema>;

package/dist/src/integrations/contracts/config.js

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+import { surfaceCapabilitySchema } from '../../orchestration/index.js';
+const conversationConfigSchema = z
+    .object({ capabilities: z.array(surfaceCapabilitySchema).readonly() })
+    .strict();
 const providerEntrySchema = z
     .looseObject({
     provider: z
@@ -7,6 +11,9 @@ const providerEntrySchema = z
         .regex(/^[a-z][a-z0-9-]*$/)
         .optional(),
     enabled: z.boolean().default(true),
+    // This is adapter-instance policy. It is intentionally outside provider-specific
+    // configuration so two instances of one provider can have different authority.
+    conversation: conversationConfigSchema.optional(),
 })
     .transform((value) => ({ ...value, enabled: value.enabled ?? true }));
 export const integrationsConfigSchema = z

package/dist/src/integrations/contracts/provider.d.ts

@@ -3,7 +3,7 @@ import type { PullRequestService } from '../../activities/index.js';
 import type { ConversationService } from '../../conversations/index.js';
 import type { RunRepository } from '../../execution/index.js';
 import type { Clock, IdGenerator } from '../../kernel/index.js';
-import type { OrchestrationService, WorkflowCandidate, WorkflowName } from '../../orchestration/index.js';
+import type { OrchestrationService, SurfaceCapability, WorkflowCandidate, WorkflowName } from '../../orchestration/index.js';
 import type { ExternalResourceKey, ResourceCapability, ResourceKind, ResourceLookup, ResourceService } from '../../resources/index.js';
 import type { WorkItemId, WorkItemView, WorkService } from '../../work/index.js';
 import type { ExternalDeliveryAdapter } from '../delivery/contracts/config.js';
@@ -78,6 +78,8 @@ export type ComposedProviderInstance = Omit<ProviderInstance, 'provider'>;
 export interface ProviderDefinition<Config = unknown> {
     readonly provider: string;
     readonly eventTypes: readonly string[];
+    /** Conservative default authority for each instance of this provider type. */
+    readonly defaultConversationCapabilities?: readonly SurfaceCapability[];
     /** Provider-owned periodic reconciliation, invoked in the tick react phase. */
     readonly maintenance?: {
         readonly runOnce: () => Promise<void>;
@@ -86,6 +88,7 @@ export interface ProviderDefinition<Config = unknown> {
     create(input: {
         readonly adapter: AdapterId;
         readonly config: Config;
+        readonly conversationCapabilities?: readonly SurfaceCapability[];
         readonly services?: ProviderServices;
     }): ComposedProviderInstance;
 }

package/dist/src/integrations/contracts/provider.js

@@ -18,10 +18,12 @@ export class ProviderRegistry {
                 throw new Error(`Provider ${provider} is not registered`);
             const adapter = adapterId(name);
             try {
+                const { conversation: _conversation, provider: _provider, ...providerConfig } = entry;
                 instances.push({
                     ...definition.create({
                         adapter,
-                        config: definition.parseConfig(entry),
+                        config: definition.parseConfig(providerConfig),
+                        conversationCapabilities: entry.conversation?.capabilities ?? definition.defaultConversationCapabilities ?? [],
                         ...(services === undefined ? {} : { services }),
                     }),
                     provider,

package/dist/src/integrations/github/application/inbound-comment-syntax.d.ts

@@ -1,7 +1,7 @@
 import { ReviewActorKind } from '../../../activities/index.js';
 import { GitHubBuiltInCommand } from '../contracts/vocabulary.js';
 export declare function isHumanNonWakeReply(actorKind: ReviewActorKind, body: string): boolean;
-type IssueCommand = typeof GitHubBuiltInCommand.Approved | typeof GitHubBuiltInCommand.Changes | typeof GitHubBuiltInCommand.Retry | typeof GitHubBuiltInCommand.Restart | typeof GitHubBuiltInCommand.Extend;
+type IssueCommand = typeof GitHubBuiltInCommand.Approved | typeof GitHubBuiltInCommand.Accepted | typeof GitHubBuiltInCommand.Changes | typeof GitHubBuiltInCommand.Retry | typeof GitHubBuiltInCommand.Restart | typeof GitHubBuiltInCommand.Extend;
 export declare function recognizedCommand(body: string): IssueCommand | null;
 export declare function isPlainReply(body: string): boolean;
 export declare function shouldResumeBlockedStage(command: IssueCommand | null, plainReply: boolean): boolean;

package/dist/src/integrations/github/application/inbound-comment-syntax.js

@@ -16,13 +16,15 @@ export function recognizedCommand(body) {
     const line = commandLine(body);
     if (matchesCommand(line, GitHubBuiltInCommand.Approved))
         return GitHubBuiltInCommand.Approved;
+    if (matchesCommand(line, GitHubBuiltInCommand.Accepted))
+        return GitHubBuiltInCommand.Accepted;
     if (matchesCommand(line, GitHubBuiltInCommand.Changes))
         return GitHubBuiltInCommand.Changes;
     if (matchesCommand(line, GitHubBuiltInCommand.Retry))
         return GitHubBuiltInCommand.Retry;
     if (matchesCommand(line, GitHubBuiltInCommand.Restart))
         return GitHubBuiltInCommand.Restart;
-    if (line === GitHubBuiltInCommand.Extend)
+    if (matchesCommand(line, GitHubBuiltInCommand.Extend))
         return GitHubBuiltInCommand.Extend;
     return null;
 }

package/dist/src/integrations/github/application/inbound-review-signals.d.ts

@@ -17,5 +17,7 @@ export declare function applyReviewSignal(input: {
     readonly ids: IdGenerator;
     readonly adapter: AdapterId;
     readonly orchestration: OrchestrationService | undefined;
+    /** The shared conversation dispatcher owns slash commands in the normal inbound path. */
+    readonly applyIssueCommands?: boolean;
 }): Promise<void>;
 export {};

package/dist/src/integrations/github/application/inbound-review-signals.js

@@ -8,12 +8,20 @@ import { commandContext } from './inbound-context.js';
 import { ignoreIneligibleOperatorRetry } from './operator-retry-command.js';
 import { translateGitHubReviewCommand } from './review-command-translator.js';
 export async function applyReviewSignal(input) {
-    const { event, journal, resources, work, lookup, adapter, orchestration } = input;
+    const { event, journal, resources, work, lookup, adapter, orchestration, applyIssueCommands } = input;
     if (journal === undefined || resources === undefined || work === undefined)
         return;
     const payload = event.event.payload;
     if (payload.reviewKind === 'issue') {
-        await applyIssueReviewSignal({ event, resources, work, lookup, orchestration, adapter });
+        await applyIssueReviewSignal({
+            event,
+            resources,
+            work,
+            lookup,
+            orchestration,
+            adapter,
+            ...(applyIssueCommands === undefined ? {} : { applyIssueCommands }),
+        });
         return;
     }
     await applyFormalReviewSignal({ ...input, journal, resources, work });
@@ -62,7 +70,7 @@ async function applyFormalReviewSignal(input) {
     });
 }
 async function applyIssueReviewSignal(input) {
-    const { event, resources, work, lookup, orchestration, adapter } = input;
+    const { event, resources, work, lookup, orchestration, adapter, applyIssueCommands } = input;
     if (!isHumanNonWakeReply(event.event.payload.actor.kind, event.event.payload.body))
         return;
     if (resources === undefined || lookup === undefined || orchestration === undefined)
@@ -76,7 +84,11 @@ async function applyIssueReviewSignal(input) {
     const resource = await resources.get(resourceIdValue);
     const command = recognizedCommand(event.event.payload.body);
     const plainReply = isPlainReply(event.event.payload.body);
-    if (command !== null)
+    // Direct compatibility callers retain the legacy handler; the normal inbound
+    // path records first and has the shared dispatcher handle the command exactly once.
+    if (command !== null) {
+        if (applyIssueCommands === false)
+            return;
         return applyIssueCommand({
             event,
             command,
@@ -88,6 +100,7 @@ async function applyIssueReviewSignal(input) {
             adapter,
             resourceId: resourceIdValue,
         });
+    }
     if (resource?.kind === BuiltInResourceKind.PullRequest) {
         await applyWorkflowSignal({
             event,

package/dist/src/integrations/github/application/inbound-translator.d.ts

@@ -3,7 +3,7 @@ import { type ObservePullRequest, type PullRequestService } from '../../../activ
 import { type ConversationService } from '../../../conversations/index.js';
 import type { RunRepository } from '../../../execution/index.js';
 import { type IdGenerator } from '../../../kernel/index.js';
-import type { OrchestrationService } from '../../../orchestration/index.js';
+import type { ConversationSurfaceCapability, OrchestrationService } from '../../../orchestration/index.js';
 import type { ResourceLookup, ResourceService } from '../../../resources/index.js';
 import { type ResourceId } from '../../../resources/index.js';
 import type { WorkService } from '../../../work/index.js';
@@ -44,6 +44,7 @@ interface InboundTranslatorDependencies {
     readonly intake?: readonly GitHubIntakeRuleConfig[];
     readonly conclusion?: WorkConclusion;
     readonly conversations?: ConversationService;
+    readonly conversationCapabilities?: readonly ConversationSurfaceCapability[];
 }
 export declare class InboundTranslator {
     private readonly journal?;
@@ -64,6 +65,7 @@ export declare class InboundTranslator {
     private readonly intake;
     private readonly conclusion;
     private readonly conversations;
+    private readonly conversationCapabilities;
     private conversationRecordRecoveryPending;
     private reconcileOnce;
     private selectInboundEvent;
@@ -73,6 +75,7 @@ export declare class InboundTranslator {
     private recordConversationDeferred;
     private appendConversationRecordFact;
     private recordConversationEntry;
+    private applyConversationCommand;
     private failureRecorded;
     private retryRecorded;
     private recordTranslationRecovery;

package/dist/src/integrations/github/application/inbound-translator.js

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines */
 import { correlationId, defineEventProcessor, EventActorKind, EventProcessorCategory, EventProcessorReplayPolicy, EventSourceKind, WrongExpectedSequenceError, } from '@atolis-hq/eventing';
-import { ActivityEventType, createPullRequestService, selectActivityEvent, } from '../../../activities/index.js';
+import { ActivityEventType, createPullRequestService, isReviewAuthorized, ReviewerAuthorizationSource, selectActivityEvent, } from '../../../activities/index.js';
 import { conversationIdForWorkItem, ConversationOriginKind, } from '../../../conversations/index.js';
 import { UlidIdGenerator } from '../../../kernel/index.js';
 import { BuiltInResourceCapability, BuiltInResourceKind, ResourceCorrelationRole, ResourceEventType, resourceId, resourceStream, selectResourceEvent, } from '../../../resources/index.js';
@@ -12,7 +12,7 @@ import { deliveryStream, integrationStream } from '../../contracts/streams.js';
 import { DeliveryEventType, selectDeliveryEvent } from '../../delivery/contracts/events.js';
 import { createGitHubEventData } from '../contracts/event-factory.js';
 import { GitHubEventType, selectGitHubAdapterEvent } from '../contracts/events.js';
-import { GitHubAdapter } from '../contracts/vocabulary.js';
+import { GitHubAdapter, UnknownGitHubIdentity } from '../contracts/vocabulary.js';
 import { commandContext } from './inbound-context.js';
 import { applyReviewSignal } from './inbound-review-signals.js';
 import { applyWatchGateVerdictSignal } from './inbound-watch-gate-signals.js';
@@ -62,6 +62,7 @@ export class InboundTranslator {
         this.intake = gitHubIntakeRules(dependencies.intake ?? []);
         this.conclusion = dependencies.conclusion;
         this.conversations = dependencies.conversations;
+        this.conversationCapabilities = dependencies.conversationCapabilities ?? [];
         this.processor = defineEventProcessor({
             consumer: `reactor:integration.${this.adapter}.inbound`,
             name: `integration.${this.adapter}.inbound`,
@@ -83,6 +84,7 @@ export class InboundTranslator {
     intake;
     conclusion;
     conversations;
+    conversationCapabilities;
     conversationRecordRecoveryPending;
     async reconcileOnce() {
         if (this.journal === undefined || this.work === undefined || this.resources === undefined) {
@@ -119,6 +121,7 @@ export class InboundTranslator {
                         ids: this.ids,
                         adapter: this.adapter,
                         orchestration: this.orchestration,
+                        applyIssueCommands: false,
                     });
                 await applyWatchGateVerdictSignal({
                     event: owned,
@@ -223,7 +226,7 @@ export class InboundTranslator {
             entry.origin.messageId === externalId);
         if (existing?.entries.some((entry) => entry.representations.some((representation) => representation.resourceId === resource.resourceId &&
             representation.externalId === externalId)))
-            return;
+            return this.applyConversationCommand(correlation.workItemId, event);
         if (priorEntry !== undefined) {
             if (priorEntry.body !== event.event.payload.body)
                 await this.conversations.revise({
@@ -231,7 +234,7 @@ export class InboundTranslator {
                     entryId: priorEntry.entryId,
                     body: event.event.payload.body,
                 }, commandContext(event));
-            return;
+            return this.applyConversationCommand(correlation.workItemId, event);
         }
         await this.conversations.record({
             conversationId,
@@ -250,6 +253,18 @@ export class InboundTranslator {
                     : { location: event.event.payload.location }),
             },
         }, commandContext(event));
+        await this.applyConversationCommand(correlation.workItemId, event);
+    }
+    async applyConversationCommand(workItemId, event) {
+        // Native formal reviews already carry their own verified decision and workflow signal.
+        if (event.event.payload.reviewKind !== 'issue')
+            return;
+        await this.orchestration?.applyConversationCommand(workItemId, {
+            body: event.event.payload.body,
+            actorId: event.event.payload.actor.id,
+            capabilities: this.conversationCapabilities,
+            authorized: isAuthorizedConversationActor(event),
+        }, commandContext(event));
     }
     async failureRecorded(sourceEventId) {
         return (await this.journal.readStream(integrationStream(this.adapter))).some((event) => {
@@ -708,6 +723,15 @@ export class InboundTranslator {
         }
     }
 }
+function isAuthorizedConversationActor(event) {
+    const { actor, authorization, resourceAuthorId } = event.event.payload;
+    return isReviewAuthorized({
+        actorId: actor.id,
+        actorKind: actor.kind,
+        resourceAuthorId: resourceAuthorId ?? UnknownGitHubIdentity,
+        authorization: authorization ?? { source: ReviewerAuthorizationSource.None },
+    });
+}
 function observedCommentExternalId(event) {
     const id = event.event.payload.raw.id;
     return typeof id === 'string' || typeof id === 'number' ? String(id) : event.event.eventId;

package/dist/src/integrations/github/contracts/events.d.ts

@@ -31,6 +31,8 @@ export interface ExternalWorkObservedPayload {
         readonly id: string;
         readonly kind: typeof ReviewActorKind.Human | typeof ReviewActorKind.Bot;
     };
+    /** Issue or pull-request author, used to reject self-approval. */
+    readonly resourceAuthorId?: string | undefined;
     readonly labels?: readonly string[] | undefined;
     readonly assignees?: readonly string[] | undefined;
     readonly changedFiles?: readonly string[] | undefined;
@@ -71,6 +73,8 @@ interface GitHubIssueCommentObservedPayload {
         readonly id: string;
         readonly kind: typeof ReviewActorKind.Human | typeof ReviewActorKind.Bot;
     };
+    /** Issue or pull-request author, used to reject self-approval. */
+    readonly resourceAuthorId?: string | undefined;
     /** Provider-derived authority for an operator command, when available. */
     readonly authorization?: ReviewerAuthorizationEvidence | undefined;
     readonly raw: Readonly<Record<string, unknown>>;

package/dist/src/integrations/github/contracts/events.js

@@ -115,6 +115,7 @@ const githubEventSchemas = {
                 .strict()
                 .optional(),
             actor: actorSchema,
+            resourceAuthorId: z.string().optional(),
             authorization: authorizationSchema.optional(),
             raw: rawSchema,
         })

package/dist/src/integrations/github/infrastructure/comment-source.js

@@ -1,5 +1,5 @@
 import { ReviewerAuthorizationSource, } from '../../../activities/index.js';
-import { GitHubBuiltInCommand } from '../contracts/vocabulary.js';
+import { conversationCommand } from '../../../orchestration/index.js';
 import { issueCommentObservation } from './issue-source.js';
 import { mergeBatches, reportPartialPollFailure } from './poll-watermark.js';
 import { githubReviewObservation } from './review-source.js';
@@ -59,7 +59,7 @@ export async function issueCommentEventsFor(context, issues, since) {
     return mergeBatches(items);
 }
 async function issueCommentEventsForComment(context, issue, comment) {
-    const authorization = await retryAuthorization(context, comment);
+    const authorization = await commandAuthorization(context, comment);
     const event = issueCommentObservation({
         repository: context.repository,
         issue,
@@ -69,9 +69,10 @@ async function issueCommentEventsForComment(context, issue, comment) {
     });
     return event === null ? [] : [event];
 }
-async function retryAuthorization(context, comment) {
-    const command = comment.body?.trim().toLowerCase();
-    if (command !== GitHubBuiltInCommand.Retry && command !== GitHubBuiltInCommand.Restart)
+async function commandAuthorization(context, comment) {
+    if (comment.body === null ||
+        comment.body === undefined ||
+        conversationCommand(comment.body) === null)
         return undefined;
     const login = comment.user?.login;
     if (login === undefined || context.client.collaboratorPermission === undefined)

package/dist/src/integrations/github/infrastructure/issue-source.d.ts

@@ -11,7 +11,7 @@ export declare function issueObservation(input: {
 }>;
 export declare function issueCommentObservation(input: {
     readonly repository: string;
-    readonly issue: Pick<GitHubIssuePayload, 'number'>;
+    readonly issue: Pick<GitHubIssuePayload, 'number' | 'user'>;
     readonly comment: GitHubIssueCommentPayload;
     readonly authorization?: ReviewerAuthorizationEvidence;
     readonly adapter?: AdapterId;

package/dist/src/integrations/github/infrastructure/issue-source.js

@@ -69,6 +69,7 @@ function parseRepository(repository) {
         throw new Error(`Invalid GitHub repository: ${repository}`);
     return { owner, repo };
 }
+// eslint-disable-next-line complexity -- provider payload normalization keeps one canonical envelope.
 export function issueCommentObservation(input) {
     const body = input.comment.body?.trim();
     if (body === undefined || body.length === 0)
@@ -96,6 +97,7 @@ export function issueCommentObservation(input) {
                 id: input.comment.user?.login ?? UnknownGitHubIdentity,
                 kind: input.comment.user?.type === 'Bot' ? ReviewActorKind.Bot : ReviewActorKind.Human,
             },
+            resourceAuthorId: input.issue.user?.login ?? UnknownGitHubIdentity,
             ...(input.authorization === undefined ? {} : { authorization: input.authorization }),
             raw: { id: input.comment.id },
         },

package/dist/src/integrations/github/provider.js

@@ -1,4 +1,5 @@
 import { BuiltInActivityName, PullRequestState } from '../../activities/index.js';
+import { ConversationSurfaceCapability } from '../../orchestration/index.js';
 import { BuiltInResourceCapability, BuiltInResourceKind, ResourceCorrelationRole, resourceId, resourceKind, } from '../../resources/index.js';
 import { ArtifactVerificationResult } from '../contracts/artifact-vocabulary.js';
 import { InboundTranslator } from './application/inbound-translator.js';
@@ -16,10 +17,11 @@ import { createGitHubSource } from './infrastructure/source.js';
 export const gitHubProviderDefinition = {
     provider: 'github',
     eventTypes: Object.values(GitHubEventType),
+    defaultConversationCapabilities: [ConversationSurfaceCapability.Review],
     parseConfig(value) {
         return gitHubConfigSchema.parse(value);
     },
-    create({ adapter, config, services }) {
+    create({ adapter, config, conversationCapabilities = [ConversationSurfaceCapability.Review], services, }) {
         if (services === undefined)
             throw new Error('GitHub provider requires composed services');
         const client = createGitHubClient(config.token ?? resolveGitHubCliToken());
@@ -38,6 +40,7 @@ export const gitHubProviderDefinition = {
             intake: config.intake,
             conclusion: services.conclusion,
             conversations: services.conversations,
+            conversationCapabilities,
         });
         return {
             adapter,

package/dist/src/orchestration/application/conversation-command.d.ts

@@ -0,0 +1,22 @@
+import type { CommandContext } from '@atolis-hq/eventing';
+import { ActivityOutcomeKind } from '../../activities/index.js';
+import { type WorkflowInstanceId } from '../contracts/identifiers.js';
+import type { WorkflowInstanceView } from '../contracts/views.js';
+import { ConversationSurfaceCapability } from '../contracts/vocabulary.js';
+export declare const BuiltInConversationCommands: ("/approved" | "/accepted" | "/changes" | "/retry" | "/restart" | "/extend")[];
+export type SurfaceCapability = ConversationSurfaceCapability;
+export type ConversationCommandSurface = {
+    readonly capabilities: readonly SurfaceCapability[];
+};
+export declare function conversationCommand(body: string): string | null;
+export declare function applyBuiltInConversationCommand(input: {
+    readonly command: string;
+    readonly capabilities: readonly SurfaceCapability[];
+    readonly workflows: readonly WorkflowInstanceView[];
+    readonly context: CommandContext;
+    readonly acceptSignal: (id: WorkflowInstanceId, outcome: typeof ActivityOutcomeKind.Done | typeof ActivityOutcomeKind.Rejected) => Promise<unknown>;
+    readonly retry: (id: WorkflowInstanceId) => Promise<unknown>;
+    readonly restart: (id: WorkflowInstanceId) => Promise<unknown>;
+    readonly extend: (id: WorkflowInstanceId) => Promise<unknown>;
+    readonly resumeChanges: (id: WorkflowInstanceId) => Promise<unknown>;
+}): Promise<boolean>;

package/dist/src/orchestration/application/conversation-command.js

@@ -0,0 +1,46 @@
+import { ActivityOutcomeKind } from '../../activities/index.js';
+import { ConversationBuiltInCommand, ConversationSurfaceCapability, } from '../contracts/vocabulary.js';
+import { isGroupBudgetExtensionEligible, isOperatorRetryEligible, selectOperatorRetryTarget, } from '../domain/operator-retry-policy.js';
+export const BuiltInConversationCommands = Object.values(ConversationBuiltInCommand);
+export function conversationCommand(body) {
+    const line = body.trim().split('\n', 1)[0]?.trim().toLowerCase() ?? '';
+    return /^\/[a-z][a-z0-9-]*(?:\s.*)?$/.test(line) ? line.split(/\s/, 1)[0] : null;
+}
+// The command matrix is intentionally explicit so future built-ins cannot silently inherit power.
+// eslint-disable-next-line complexity
+export async function applyBuiltInConversationCommand(input) {
+    if (!BuiltInConversationCommands.includes(input.command))
+        return false;
+    if (!input.capabilities.includes(ConversationSurfaceCapability.Review) &&
+        !input.capabilities.includes(ConversationSurfaceCapability.Operator))
+        return false;
+    if (input.command === ConversationBuiltInCommand.Approved ||
+        input.command === ConversationBuiltInCommand.Accepted ||
+        input.command === ConversationBuiltInCommand.Changes) {
+        const outcome = input.command === ConversationBuiltInCommand.Changes
+            ? ActivityOutcomeKind.Rejected
+            : ActivityOutcomeKind.Done;
+        for (const workflow of input.workflows) {
+            if (workflow.waitingFor !== undefined)
+                await input.acceptSignal(workflow.workflowInstanceId, outcome);
+            else if (input.command === ConversationBuiltInCommand.Changes)
+                await input.resumeChanges(workflow.workflowInstanceId);
+        }
+        return true;
+    }
+    if (input.command === ConversationBuiltInCommand.Retry) {
+        const target = selectOperatorRetryTarget(input.workflows);
+        if (target !== undefined)
+            await input.retry(target.workflowInstanceId);
+        return true;
+    }
+    const primary = input.workflows.find((workflow) => workflow.parentWorkflowInstanceId === undefined);
+    if (primary === undefined)
+        return true;
+    if (input.command === ConversationBuiltInCommand.Restart && isOperatorRetryEligible(primary))
+        await input.restart(primary.workflowInstanceId);
+    if (input.command === ConversationBuiltInCommand.Extend &&
+        isGroupBudgetExtensionEligible(primary))
+        await input.extend(primary.workflowInstanceId);
+    return true;
+}

package/dist/src/orchestration/application/orchestration-repository.js

@@ -24,6 +24,16 @@ export class OrchestrationRepository {
         return { sequence: loaded.sequence, view: loaded.view };
     }
     async append(id, sequence, drafts) {
+        // Command and processor recovery may replay a completed append. Event IDs are
+        // deterministic from the command causation, so acknowledge that exact intent
+        // instead of appending a second copy after a crash between append and receipt.
+        const existing = await this.journal.readStream(workflowInstanceStream(workflowInstanceId(id)));
+        const existingIds = new Set(existing.map((event) => event.event.eventId));
+        if (drafts.every((draft) => existingIds.has(draft.eventId)))
+            return existing
+                .filter((event) => drafts.some((draft) => draft.eventId === event.event.eventId))
+                .map(decodeOrchestrationEvent)
+                .filter(isWorkflowEvent);
         const events = await this.journal.appendToStream(workflowInstanceStream(workflowInstanceId(id)), sequence, drafts);
         return events.map(decodeOrchestrationEvent).filter(isWorkflowEvent);
     }

package/dist/src/orchestration/application/orchestration-service.d.ts

@@ -1,12 +1,13 @@
 import type { CommandContext, EventJournal, ProjectionStore } from '@atolis-hq/eventing';
 import type { ActivationId, ActivityOutcome } from '../../activities/index.js';
-import type { WorkItemId, WorkService } from '../../work/index.js';
+import { type WorkItemId, type WorkService } from '../../work/index.js';
 import type { StartWorkflowInstance } from '../contracts/commands.js';
 import type { CompiledWorkflow, TransitionTarget } from '../contracts/config.js';
 import type { ChildWorkflowRequest, OrchestrationSignal, SignalExpectation, SupplementalActivityRequest } from '../contracts/events.js';
 import { type SignalName, type WorkflowInstanceId } from '../contracts/identifiers.js';
 import type { WorkflowInstanceView } from '../contracts/views.js';
 import { AdvanceWorkflow } from './advance-workflow.js';
+import { type SurfaceCapability } from './conversation-command.js';
 export declare class OrchestrationService {
     private readonly startWorkflow;
     private readonly acceptActivityOutcome;
@@ -19,6 +20,7 @@ export declare class OrchestrationService {
     private readonly claims;
     private readonly journal;
     private readonly definitions;
+    private readonly work;
     constructor(journal: EventJournal, work: WorkService, definitions: Readonly<Record<string, CompiledWorkflow>>, projections?: ProjectionStore);
     start(command: StartWorkflowInstance, context: CommandContext): Promise<WorkflowInstanceView>;
     requestChild(request: ChildWorkflowRequest & {
@@ -35,6 +37,13 @@ export declare class OrchestrationService {
     setAcceptSignalOperationCoordinator(coordinator: OperationCoordinator): void;
     setWatchChildCancellation(cancellation: WatchChildCancellation): void;
     requestSupplementalActivity(workflowInstanceId: WorkflowInstanceId, request: SupplementalActivityRequest, context: CommandContext): Promise<WorkflowInstanceView>;
+    applyConversationCommand(workItemId: WorkItemId, input: {
+        readonly body: string;
+        readonly actorId: string;
+        readonly capabilities: readonly SurfaceCapability[];
+        /** The adapter authenticated and authorized the actor for command control. */
+        readonly authorized: boolean;
+    }, context: CommandContext): Promise<boolean>;
     markActivationStarted(workflowInstanceId: WorkflowInstanceId, activationId: ActivationId, context: CommandContext): Promise<WorkflowInstanceView | null>;
     validateActivationDispatch(workflowInstanceId: WorkflowInstanceId, context: CommandContext): Promise<boolean>;
     block(workflowInstanceId: WorkflowInstanceId, reason: string, context: CommandContext): Promise<WorkflowInstanceView | null>;

package/dist/src/orchestration/application/orchestration-service.js

@@ -1,12 +1,14 @@
+import { WorkStatus } from '../../work/index.js';
 import { selectOrchestrationEvent } from '../contracts/event-decoder.js';
 import { OrchestrationEventType } from '../contracts/events.js';
-import { workflowInstanceId as toWorkflowInstanceId, } from '../contracts/identifiers.js';
+import { commandName, workflowInstanceId as toWorkflowInstanceId, } from '../contracts/identifiers.js';
 import { childOrchestrationGroupStream, workflowInstanceStream } from '../contracts/streams.js';
 import { ApprovalAuthorityKind } from '../contracts/vocabulary.js';
 import { isGroupBudgetExtensionEligible } from '../domain/operator-retry-policy.js';
 import { AcceptActivityOutcome } from './accept-activity-outcome.js';
 import { AcceptSignal } from './accept-signal.js';
 import { AdvanceWorkflow } from './advance-workflow.js';
+import { applyBuiltInConversationCommand, conversationCommand, } from './conversation-command.js';
 import { CoordinationClaims } from './coordination-claims.js';
 import { GroupBudgetRecorder } from './group-budget-recorder.js';
 import { workflowsByWorkItemProjection } from './orchestration-projection.js';
@@ -27,9 +29,11 @@ export class OrchestrationService {
     claims;
     journal;
     definitions;
+    work;
     constructor(journal, work, definitions, projections) {
         this.projections = projections;
         this.journal = journal;
+        this.work = work;
         const repository = new OrchestrationRepository(journal);
         this.claims = new CoordinationClaims(journal);
         this.definitions = new WorkflowDefinitionRegistry(journal, projections, definitions);
@@ -66,6 +70,49 @@ export class OrchestrationService {
     requestSupplementalActivity(workflowInstanceId, request, context) {
         return this.advanceWorkflow.requestSupplementalActivity(workflowInstanceId, request, context);
     }
+    async applyConversationCommand(workItemId, input, context) {
+        const command = conversationCommand(input.body);
+        if (command === null)
+            return false;
+        if (!input.authorized)
+            return false;
+        const work = await this.work.get(workItemId);
+        if (work === null || work.deleted || work.frozen || work.state !== WorkStatus.Open)
+            return false;
+        // A command is causally adjacent to its conversation entry; projections may lag
+        // the journal, so command application must read the authoritative workflow state.
+        const workflows = (await this.advanceWorkflow.listAll()).filter((workflow) => workflow.workItemId === workItemId);
+        // Configured commands deliberately win over built-ins, even when their spelling collides.
+        let supplemental = false;
+        for (const workflow of workflows) {
+            const definition = await this.definitions.resolve(workflow);
+            if (definition.commands[command] === undefined)
+                continue;
+            supplemental = true;
+            await this.requestSupplementalActivity(workflow.workflowInstanceId, { command: commandName(command) }, context);
+        }
+        if (supplemental)
+            return true;
+        return applyBuiltInConversationCommand({
+            command,
+            capabilities: input.capabilities,
+            workflows,
+            context,
+            acceptSignal: (id, outcome) => this.acceptSignal(id, {
+                kind: (workflows.find((workflow) => workflow.workflowInstanceId === id)?.waitingFor
+                    ?.signalKind ?? 'approved'),
+                outcome,
+                actorId: input.actorId,
+                actorDecision: { authorized: true, evidenceId: context.commandId },
+                providerEventId: context.commandId,
+                authority: { kind: ApprovalAuthorityKind.Human },
+            }, context),
+            retry: (id) => this.retryBlockedFailedStage(id, context),
+            restart: (id) => this.restartBlockedFailedStage(id, context),
+            extend: (id) => this.extendBlockedGroupBudget(id, { kind: ApprovalAuthorityKind.Human }, context),
+            resumeChanges: (id) => this.resumeBlockedStageForChanges(id, context),
+        });
+    }
     markActivationStarted(workflowInstanceId, activationId, context) {
         return this.advanceWorkflow.markActivationStarted(workflowInstanceId, activationId, context);
     }

package/dist/src/orchestration/contracts/config.d.ts

@@ -37,6 +37,11 @@ declare const resourceTransitionConfigSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>;
     then: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>]>;
+export declare const surfaceCapabilitySchema: z.ZodEnum<{
+    "review-surface": "review-surface";
+    "chat-surface": "chat-surface";
+    "operator-surface": "operator-surface";
+}>;
 export declare const watchConfigSchema: z.ZodObject<{
     id: z.ZodString;
     while: z.ZodObject<{

package/dist/src/orchestration/contracts/config.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { ApprovalAuthorityKind, WorkflowStatus } from './vocabulary.js';
+import { ApprovalAuthorityKind, ConversationSurfaceCapability, WorkflowStatus, } from './vocabulary.js';
 import { ActivityEventType, PullRequestCheckState, PullRequestState, } from '../../activities/index.js';
 import { WorkspaceMode } from '../../execution/index.js';
 import { MatchMode } from '../../kernel/index.js';
@@ -54,6 +54,11 @@ const resourceTransitionConfigSchema = z.union([
         .strict(),
 ]);
 const commandName = z.string().regex(/^\/[a-z][a-z0-9-]*$/);
+export const surfaceCapabilitySchema = z.enum([
+    ConversationSurfaceCapability.Review,
+    ConversationSurfaceCapability.Chat,
+    ConversationSurfaceCapability.Operator,
+]);
 const canonicalEventName = z.string().regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/);
 const watchStatus = z.enum([WorkflowStatus.Active, WorkflowStatus.Waiting, WorkflowStatus.Blocked]);
 const failingChecksWatchPredicateSchema = z

package/dist/src/orchestration/contracts/vocabulary.d.ts

@@ -32,3 +32,18 @@ export declare const ApprovalAuthorityKind: {
     readonly Watch: "watch";
 };
 export type ApprovalAuthorityKind = ValueOf<typeof ApprovalAuthorityKind>;
+export declare const ConversationBuiltInCommand: {
+    readonly Approved: "/approved";
+    readonly Accepted: "/accepted";
+    readonly Changes: "/changes";
+    readonly Retry: "/retry";
+    readonly Restart: "/restart";
+    readonly Extend: "/extend";
+};
+export type ConversationBuiltInCommand = ValueOf<typeof ConversationBuiltInCommand>;
+export declare const ConversationSurfaceCapability: {
+    readonly Review: "review-surface";
+    readonly Chat: "chat-surface";
+    readonly Operator: "operator-surface";
+};
+export type ConversationSurfaceCapability = ValueOf<typeof ConversationSurfaceCapability>;

package/dist/src/orchestration/contracts/vocabulary.js

@@ -29,3 +29,16 @@ export const ApprovalAuthorityKind = defineClosedVocabulary({
     Auto: 'auto',
     Watch: 'watch',
 });
+export const ConversationBuiltInCommand = defineClosedVocabulary({
+    Approved: '/approved',
+    Accepted: '/accepted',
+    Changes: '/changes',
+    Retry: '/retry',
+    Restart: '/restart',
+    Extend: '/extend',
+});
+export const ConversationSurfaceCapability = defineClosedVocabulary({
+    Review: 'review-surface',
+    Chat: 'chat-surface',
+    Operator: 'operator-surface',
+});

package/dist/src/orchestration/index.d.ts

@@ -10,6 +10,7 @@ export * from './application/resource-transition-reactor.js';
 export * from './application/signal-reactor.js';
 export * from './application/watch-reactor.js';
 export * from './application/trigger-workflow-instance.js';
+export * from './application/conversation-command.js';
 export * from './application/workflow-definition-registry.js';
 export * from './contracts/activity-outcome.js';
 export * from './contracts/commands.js';

package/dist/src/orchestration/index.js

@@ -10,6 +10,7 @@ export * from './application/resource-transition-reactor.js';
 export * from './application/signal-reactor.js';
 export * from './application/watch-reactor.js';
 export * from './application/trigger-workflow-instance.js';
+export * from './application/conversation-command.js';
 export * from './application/workflow-definition-registry.js';
 export * from './contracts/activity-outcome.js';
 export * from './contracts/commands.js';

package/dist/src/surfaces/cli/usage.js

@@ -24,7 +24,7 @@ export const usage = [
     '  wake run resolve <run-id> --failed --reason <message>',
     '  wake api                   Run the target API surface',
     '  wake sandbox-entrypoint    Run the sandbox resident entrypoint',
-    '  wake self-update           Safely update a source installation',
+    '  wake self-update           Safely update Wake from npm or a source checkout',
     '',
     'Getting started:',
     '  1. wake init ./wake-home',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.4.15",
+  "version": "0.4.17",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {