@devtrack-solution/codesdd 1.2.3 → 1.2.4

package/dist/core/config-schema.js

@@ -20,6 +20,36 @@ export const GlobalConfigSchema = z
     workflows: z
         .array(z.string())
         .optional(),
+    redis: z
+        .object({
+        enabled: z.boolean().optional(),
+        url: z.string().min(1).optional(),
+        url_env: z.string().min(1).optional(),
+        namespace: z.string().min(1).optional(),
+        tls: z.boolean().optional(),
+        connect_timeout_ms: z.number().int().positive().optional(),
+        command_timeout_ms: z.number().int().positive().optional(),
+        max_retries: z.number().int().min(0).optional(),
+        fallback: z.enum(['filesystem', 'none']).optional(),
+        cache_default_ttl_ms: z.number().int().positive().optional(),
+        lock_ttl_ms: z.number().int().positive().optional(),
+        stream_max_len: z.number().int().positive().optional(),
+    })
+        .optional(),
+    enterprise: z
+        .object({
+        provisioning: z
+            .object({
+            mode: z.enum(['local', 'enterprise']).optional(),
+            project_id: z.string().min(1).optional(),
+            authority_url: z.string().min(1).optional(),
+            authority_url_env: z.string().min(1).optional(),
+            tenant_id: z.string().min(1).optional(),
+            required_for_numbered_artifacts: z.boolean().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
 })
     .passthrough();
 /**
@@ -30,7 +60,7 @@ export const DEFAULT_CONFIG = {
     profile: 'core',
     delivery: 'both',
 };
-const KNOWN_TOP_LEVEL_KEYS = new Set([...Object.keys(DEFAULT_CONFIG), 'workflows']);
+const KNOWN_TOP_LEVEL_KEYS = new Set([...Object.keys(DEFAULT_CONFIG), 'workflows', 'redis', 'enterprise']);
 const SENSITIVE_KEY_TOKENS = ['key', 'secret', 'token', 'password', 'credential', 'private', 'auth'];
 /**
  * Validate a config key path for CLI set operations.
@@ -51,6 +81,46 @@ export function validateConfigKeyPath(path) {
         }
         return { valid: true };
     }
+    if (rootKey === 'redis') {
+        if (rawKeys.length !== 2) {
+            return { valid: false, reason: 'redis settings support one nested key' };
+        }
+        const redisKeys = new Set([
+            'enabled',
+            'url',
+            'url_env',
+            'namespace',
+            'tls',
+            'connect_timeout_ms',
+            'command_timeout_ms',
+            'max_retries',
+            'fallback',
+            'cache_default_ttl_ms',
+            'lock_ttl_ms',
+            'stream_max_len',
+        ]);
+        if (!redisKeys.has(rawKeys[1])) {
+            return { valid: false, reason: `Unknown redis key "${rawKeys[1]}"` };
+        }
+        return { valid: true };
+    }
+    if (rootKey === 'enterprise') {
+        if (rawKeys.length !== 3 || rawKeys[1] !== 'provisioning') {
+            return { valid: false, reason: 'enterprise settings use enterprise.provisioning.<key>' };
+        }
+        const provisioningKeys = new Set([
+            'mode',
+            'project_id',
+            'authority_url',
+            'authority_url_env',
+            'tenant_id',
+            'required_for_numbered_artifacts',
+        ]);
+        if (!provisioningKeys.has(rawKeys[2])) {
+            return { valid: false, reason: `Unknown enterprise provisioning key "${rawKeys[2]}"` };
+        }
+        return { valid: true };
+    }
     if (rawKeys.length > 1) {
         return { valid: false, reason: `"${rootKey}" does not support nested keys` };
     }
@@ -216,22 +286,26 @@ export function isSensitiveConfigPath(path) {
         .split('.')
         .map((segment) => segment.trim().toLowerCase())
         .filter(Boolean);
+    if (segments.length >= 2 && segments[0] === 'redis' && segments[segments.length - 1] === 'url') {
+        return true;
+    }
     return segments.some((segment) => SENSITIVE_KEY_TOKENS.some((token) => segment.includes(token)));
 }
-export function redactConfigSecrets(value) {
+export function redactConfigSecrets(value, parentPath = '') {
     if (Array.isArray(value)) {
-        return value.map((entry) => redactConfigSecrets(entry));
+        return value.map((entry) => redactConfigSecrets(entry, parentPath));
     }
     if (!value || typeof value !== 'object') {
         return value;
     }
     const redacted = {};
     for (const [key, entryValue] of Object.entries(value)) {
-        if (isSensitiveConfigPath(key)) {
+        const path = parentPath ? `${parentPath}.${key}` : key;
+        if (isSensitiveConfigPath(path)) {
             redacted[key] = '[REDACTED]';
             continue;
         }
-        redacted[key] = redactConfigSecrets(entryValue);
+        redacted[key] = redactConfigSecrets(entryValue, path);
     }
     return redacted;
 }

package/dist/core/config.d.ts

@@ -13,5 +13,6 @@ export interface AIToolOption {
     successLabel?: string;
     skillsDir?: string;
 }
+export declare function getToolInstallGuidance(toolIds: readonly string[]): string[];
 export declare const AI_TOOLS: AIToolOption[];
 //# sourceMappingURL=config.d.ts.map

package/dist/core/config.js

@@ -3,6 +3,17 @@ export const CODESDD_MARKERS = {
     start: '<!-- CODESDD:START -->',
     end: '<!-- CODESDD:END -->'
 };
+export function getToolInstallGuidance(toolIds) {
+    const normalized = new Set(toolIds.map((toolId) => toolId.toLowerCase()));
+    const notes = [];
+    if (normalized.size > 0) {
+        notes.push('Tool scope: generated assistant skills/prompts only; canonical project state stays in .sdd/.');
+    }
+    if (normalized.has('opencode')) {
+        notes.push('OpenCode tool id: use --tools opencode for generated assistant assets; use --provider open-code only for SDD MCP bridge commands.');
+    }
+    return notes;
+}
 export const AI_TOOLS = [
     { name: 'Amazon Q Developer', value: 'amazon-q', available: true, successLabel: 'Amazon Q Developer', skillsDir: '.amazonq' },
     { name: 'Antigravity', value: 'antigravity', available: true, successLabel: 'Antigravity', skillsDir: '.agent' },

package/dist/core/global-config.d.ts

@@ -7,11 +7,40 @@ export declare const LEGACY_GLOBAL_CONFIG_DIR_NAME = "codesdd";
 export declare const LEGACY_GLOBAL_CONFIG_FILE_NAME = "config.json";
 export type Profile = 'core' | 'custom';
 export type Delivery = 'both' | 'skills' | 'commands';
+export type RedisFallbackMode = 'filesystem' | 'none';
+export interface RedisGlobalConfig {
+    enabled?: boolean;
+    url?: string;
+    url_env?: string;
+    namespace?: string;
+    tls?: boolean;
+    connect_timeout_ms?: number;
+    command_timeout_ms?: number;
+    max_retries?: number;
+    fallback?: RedisFallbackMode;
+    cache_default_ttl_ms?: number;
+    lock_ttl_ms?: number;
+    stream_max_len?: number;
+}
+export type EnterpriseProvisioningMode = 'local' | 'enterprise';
+export interface EnterpriseProvisioningGlobalConfig {
+    mode?: EnterpriseProvisioningMode;
+    project_id?: string;
+    authority_url?: string;
+    authority_url_env?: string;
+    tenant_id?: string;
+    required_for_numbered_artifacts?: boolean;
+}
+export interface EnterpriseGlobalConfig {
+    provisioning?: EnterpriseProvisioningGlobalConfig;
+}
 export interface GlobalConfig {
     featureFlags?: Record<string, boolean>;
     profile?: Profile;
     delivery?: Delivery;
     workflows?: string[];
+    redis?: RedisGlobalConfig;
+    enterprise?: EnterpriseGlobalConfig;
 }
 export declare function parseTomlContent(content: string): Record<string, unknown>;
 export declare function stringifyTomlContent(value: Record<string, unknown>): string;

package/dist/core/init.d.ts

@@ -1,8 +1,8 @@
 /**
  * Init Command
  *
- * Sets up CodeSDD with Agent Skills and /opsx:* slash commands.
- * This is the unified setup command that replaces both the old init and experimental commands.
+ * Sets up CodeSDD agent skills and compatibility slash commands.
+ * The canonical project lifecycle lives under .sdd and codesdd sdd commands.
  */
 type InitCommandOptions = {
     tools?: string;

package/dist/core/init.js

@@ -1,8 +1,8 @@
 /**
  * Init Command
  *
- * Sets up CodeSDD with Agent Skills and /opsx:* slash commands.
- * This is the unified setup command that replaces both the old init and experimental commands.
+ * Sets up CodeSDD agent skills and compatibility slash commands.
+ * The canonical project lifecycle lives under .sdd and codesdd sdd commands.
  */
 import path from 'path';
 import chalk from 'chalk';
@@ -11,7 +11,7 @@ import * as fs from 'fs';
 import { createRequire } from 'module';
 import { FileSystemUtils } from '../utils/file-system.js';
 import { transformToHyphenCommands } from '../utils/command-references.js';
-import { AI_TOOLS, LEGACY_SPEC_DIR_NAME, } from './config.js';
+import { AI_TOOLS, LEGACY_SPEC_DIR_NAME, getToolInstallGuidance, } from './config.js';
 import { isInteractive } from '../utils/interactive.js';
 import { generateCommands, CommandAdapterRegistry, } from './command-generation/index.js';
 import { CLI_ISSUES_URL, CLI_NAME, CLI_PRODUCT_NAME, CLI_REPOSITORY_URL } from './branding.js';
@@ -515,6 +515,10 @@ export class InitCommand {
         if (results.removedSkillCount > 0) {
             this.log(chalk.dim(`Removed: ${results.removedSkillCount} skill directories (delivery: commands)`));
         }
+        const toolNotes = getToolInstallGuidance(successfulTools.map((tool) => tool.value));
+        for (const note of toolNotes) {
+            this.log(chalk.dim(note));
+        }
         // Config status
         if (configStatus === 'exists') {
             // Show actual filename (config.yaml or config.yml)
@@ -528,21 +532,16 @@ export class InitCommand {
         else {
             this.log(chalk.dim(`Project config: not created (SDD uses .sdd/config.yaml)`));
         }
-        // Getting started (task 7.6: show propose if in profile)
+        // Getting started
         const globalCfg = getGlobalConfig();
         const activeProfile = this.profileOverride ?? globalCfg.profile ?? 'core';
         const activeWorkflows = [...getProfileWorkflows(activeProfile, globalCfg.workflows)];
         this.log();
-        if (activeWorkflows.includes('propose')) {
-            this.log(chalk.bold('Getting started:'));
-            this.log('  Start your first change: /opsx:propose "your idea"');
-        }
-        else if (activeWorkflows.includes('new')) {
-            this.log(chalk.bold('Getting started:'));
-            this.log('  Start your first change: /opsx:new "your idea"');
-        }
-        else {
-            this.log(`Done. Run '${CLI_NAME} config profile' to configure your workflows.`);
+        this.log(chalk.bold('Getting started:'));
+        this.log(`  Full project bootstrap: ${CLI_NAME} install`);
+        this.log(`  Canonical first change: ${CLI_NAME} sdd insight "your idea"`);
+        if (activeWorkflows.includes('propose') || activeWorkflows.includes('new')) {
+            this.log(chalk.dim('  Compatibility slash commands were generated for existing workflows; prefer CodeSDD SDD commands in .sdd-native projects.'));
         }
         // Links
         this.log();

package/dist/core/sdd/agent-binding.d.ts

@@ -1,17 +1,17 @@
 import { z } from 'zod';
 declare const agentProviderSchema: z.ZodEnum<{
-    codex: "codex";
     opencode: "opencode";
+    codex: "codex";
     deepagents: "deepagents";
     fake: "fake";
     "claude-code": "claude-code";
     cloudcode: "cloudcode";
 }>;
 declare const agentTaskKindSchema: z.ZodEnum<{
+    implementation: "implementation";
     validation: "validation";
     planning: "planning";
     "reverse-engineering": "reverse-engineering";
-    implementation: "implementation";
     review: "review";
     "plugin-execution": "plugin-execution";
     "adr-governance": "adr-governance";
@@ -32,10 +32,10 @@ declare const riskTierSchema: z.ZodEnum<{
 }>;
 export declare const agentBindingCapabilitySchema: z.ZodObject<{
     task_kind: z.ZodEnum<{
+        implementation: "implementation";
         validation: "validation";
         planning: "planning";
         "reverse-engineering": "reverse-engineering";
-        implementation: "implementation";
         review: "review";
         "plugin-execution": "plugin-execution";
         "adr-governance": "adr-governance";
@@ -61,8 +61,8 @@ export declare const agentBindingAdapterSchema: z.ZodObject<{
     schema_version: z.ZodDefault<z.ZodLiteral<1>>;
     id: z.ZodString;
     provider: z.ZodEnum<{
-        codex: "codex";
         opencode: "opencode";
+        codex: "codex";
         deepagents: "deepagents";
         fake: "fake";
         "claude-code": "claude-code";
@@ -84,17 +84,17 @@ export declare const agentBindingAdapterSchema: z.ZodObject<{
         args: z.ZodDefault<z.ZodArray<z.ZodString>>;
         network: z.ZodDefault<z.ZodEnum<{
             disabled: "disabled";
-            restricted: "restricted";
             enabled: "enabled";
+            restricted: "restricted";
         }>>;
         evidence_contract: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>;
     capabilities: z.ZodArray<z.ZodObject<{
         task_kind: z.ZodEnum<{
+            implementation: "implementation";
             validation: "validation";
             planning: "planning";
             "reverse-engineering": "reverse-engineering";
-            implementation: "implementation";
             review: "review";
             "plugin-execution": "plugin-execution";
             "adr-governance": "adr-governance";
@@ -137,10 +137,10 @@ export declare const agentBindingResolutionRequestSchema: z.ZodObject<{
     schema_version: z.ZodDefault<z.ZodLiteral<1>>;
     feature_ref: z.ZodString;
     task_kind: z.ZodEnum<{
+        implementation: "implementation";
         validation: "validation";
         planning: "planning";
         "reverse-engineering": "reverse-engineering";
-        implementation: "implementation";
         review: "review";
         "plugin-execution": "plugin-execution";
         "adr-governance": "adr-governance";
@@ -148,16 +148,16 @@ export declare const agentBindingResolutionRequestSchema: z.ZodObject<{
         "documentation-sync": "documentation-sync";
     }>;
     provider: z.ZodOptional<z.ZodEnum<{
-        codex: "codex";
         opencode: "opencode";
+        codex: "codex";
         deepagents: "deepagents";
         fake: "fake";
         "claude-code": "claude-code";
         cloudcode: "cloudcode";
     }>>;
     allowed_providers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        codex: "codex";
         opencode: "opencode";
+        codex: "codex";
         deepagents: "deepagents";
         fake: "fake";
         "claude-code": "claude-code";
@@ -186,8 +186,8 @@ export declare const agentBindingCandidateSchema: z.ZodObject<{
     adapter_ref: z.ZodObject<{
         id: z.ZodString;
         provider: z.ZodEnum<{
-            codex: "codex";
             opencode: "opencode";
+            codex: "codex";
             deepagents: "deepagents";
             fake: "fake";
             "claude-code": "claude-code";
@@ -196,10 +196,10 @@ export declare const agentBindingCandidateSchema: z.ZodObject<{
         label: z.ZodString;
     }, z.core.$strip>;
     task_kind: z.ZodEnum<{
+        implementation: "implementation";
         validation: "validation";
         planning: "planning";
         "reverse-engineering": "reverse-engineering";
-        implementation: "implementation";
         review: "review";
         "plugin-execution": "plugin-execution";
         "adr-governance": "adr-governance";
@@ -213,17 +213,17 @@ export declare const agentBindingResolutionSchema: z.ZodObject<{
     schema_version: z.ZodLiteral<1>;
     created_at: z.ZodString;
     status: z.ZodEnum<{
-        resolved: "resolved";
         fallback: "fallback";
+        resolved: "resolved";
     }>;
     request: z.ZodObject<{
         schema_version: z.ZodDefault<z.ZodLiteral<1>>;
         feature_ref: z.ZodString;
         task_kind: z.ZodEnum<{
+            implementation: "implementation";
             validation: "validation";
             planning: "planning";
             "reverse-engineering": "reverse-engineering";
-            implementation: "implementation";
             review: "review";
             "plugin-execution": "plugin-execution";
             "adr-governance": "adr-governance";
@@ -231,16 +231,16 @@ export declare const agentBindingResolutionSchema: z.ZodObject<{
             "documentation-sync": "documentation-sync";
         }>;
         provider: z.ZodOptional<z.ZodEnum<{
-            codex: "codex";
             opencode: "opencode";
+            codex: "codex";
             deepagents: "deepagents";
             fake: "fake";
             "claude-code": "claude-code";
             cloudcode: "cloudcode";
         }>>;
         allowed_providers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            codex: "codex";
             opencode: "opencode";
+            codex: "codex";
             deepagents: "deepagents";
             fake: "fake";
             "claude-code": "claude-code";
@@ -269,8 +269,8 @@ export declare const agentBindingResolutionSchema: z.ZodObject<{
         adapter_ref: z.ZodObject<{
             id: z.ZodString;
             provider: z.ZodEnum<{
-                codex: "codex";
                 opencode: "opencode";
+                codex: "codex";
                 deepagents: "deepagents";
                 fake: "fake";
                 "claude-code": "claude-code";
@@ -279,10 +279,10 @@ export declare const agentBindingResolutionSchema: z.ZodObject<{
             label: z.ZodString;
         }, z.core.$strip>;
         task_kind: z.ZodEnum<{
+            implementation: "implementation";
             validation: "validation";
             planning: "planning";
             "reverse-engineering": "reverse-engineering";
-            implementation: "implementation";
             review: "review";
             "plugin-execution": "plugin-execution";
             "adr-governance": "adr-governance";
@@ -296,8 +296,8 @@ export declare const agentBindingResolutionSchema: z.ZodObject<{
         adapter_ref: z.ZodObject<{
             id: z.ZodString;
             provider: z.ZodEnum<{
-                codex: "codex";
                 opencode: "opencode";
+                codex: "codex";
                 deepagents: "deepagents";
                 fake: "fake";
                 "claude-code": "claude-code";
@@ -306,10 +306,10 @@ export declare const agentBindingResolutionSchema: z.ZodObject<{
             label: z.ZodString;
         }, z.core.$strip>;
         task_kind: z.ZodEnum<{
+            implementation: "implementation";
             validation: "validation";
             planning: "planning";
             "reverse-engineering": "reverse-engineering";
-            implementation: "implementation";
             review: "review";
             "plugin-execution": "plugin-execution";
             "adr-governance": "adr-governance";

package/dist/core/sdd/agent-runtime-contract.d.ts

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+export declare const agentRuntimeProviderSchema: z.ZodEnum<{
+    opencode: "opencode";
+    codex: "codex";
+    deepagents: "deepagents";
+}>;
+export declare const agentRuntimeModeSchema: z.ZodEnum<{
+    validate: "validate";
+    "read-only": "read-only";
+    plan: "plan";
+    "apply-sandbox": "apply-sandbox";
+    "apply-approved": "apply-approved";
+}>;
+export declare const agentRuntimeSandboxSchema: z.ZodEnum<{
+    "read-only": "read-only";
+    "workspace-write": "workspace-write";
+    "danger-full-access": "danger-full-access";
+}>;
+export declare const agentRuntimeStatusSchema: z.ZodEnum<{
+    blocked: "blocked";
+    planned: "planned";
+}>;
+export declare const opencodeExecutionStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    blocked: "blocked";
+    planned: "planned";
+    failed: "failed";
+    skipped: "skipped";
+    running: "running";
+}>;
+export declare const agentRuntimeCommandPlanRequestSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    feature_ref: z.ZodString;
+    provider: z.ZodEnum<{
+        opencode: "opencode";
+        codex: "codex";
+        deepagents: "deepagents";
+    }>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        validate: "validate";
+        "read-only": "read-only";
+        plan: "plan";
+        "apply-sandbox": "apply-sandbox";
+        "apply-approved": "apply-approved";
+    }>>;
+    instruction: z.ZodString;
+    cwd: z.ZodDefault<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    sandbox: z.ZodDefault<z.ZodEnum<{
+        "read-only": "read-only";
+        "workspace-write": "workspace-write";
+        "danger-full-access": "danger-full-access";
+    }>>;
+    output_schema: z.ZodOptional<z.ZodString>;
+    output_last_message: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodString>;
+    session: z.ZodOptional<z.ZodString>;
+    files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    approval_grants: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        maintainer: "maintainer";
+        security: "security";
+        "architecture-board": "architecture-board";
+    }>>>;
+}, z.core.$strip>;
+export declare const agentRuntimeCommandPlanSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    created_at: z.ZodString;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        planned: "planned";
+    }>;
+    request: z.ZodObject<{
+        schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+        feature_ref: z.ZodString;
+        provider: z.ZodEnum<{
+            opencode: "opencode";
+            codex: "codex";
+            deepagents: "deepagents";
+        }>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            validate: "validate";
+            "read-only": "read-only";
+            plan: "plan";
+            "apply-sandbox": "apply-sandbox";
+            "apply-approved": "apply-approved";
+        }>>;
+        instruction: z.ZodString;
+        cwd: z.ZodDefault<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        sandbox: z.ZodDefault<z.ZodEnum<{
+            "read-only": "read-only";
+            "workspace-write": "workspace-write";
+            "danger-full-access": "danger-full-access";
+        }>>;
+        output_schema: z.ZodOptional<z.ZodString>;
+        output_last_message: z.ZodOptional<z.ZodString>;
+        agent: z.ZodOptional<z.ZodString>;
+        session: z.ZodOptional<z.ZodString>;
+        files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        approval_grants: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            maintainer: "maintainer";
+            security: "security";
+            "architecture-board": "architecture-board";
+        }>>>;
+    }, z.core.$strip>;
+    provider: z.ZodEnum<{
+        opencode: "opencode";
+        codex: "codex";
+        deepagents: "deepagents";
+    }>;
+    command: z.ZodOptional<z.ZodObject<{
+        executable: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        stdin: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    evidence_contract: z.ZodEnum<{
+        "agent-runtime-v2/deepagents": "agent-runtime-v2/deepagents";
+        "agent-runtime-v2/codex-exec": "agent-runtime-v2/codex-exec";
+        "agent-runtime-v2/opencode-run": "agent-runtime-v2/opencode-run";
+    }>;
+    structured_output: z.ZodBoolean;
+    reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    policy: z.ZodObject<{
+        direct_state_write_allowed: z.ZodLiteral<false>;
+        requires_codesdd_finalize: z.ZodLiteral<true>;
+        mutating_modes_require_approval: z.ZodLiteral<true>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const opencodeExecutionEvidenceSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    contract: z.ZodLiteral<"agent-runtime-v2/opencode-run">;
+    provider: z.ZodLiteral<"opencode">;
+    feature_ref: z.ZodString;
+    run_id: z.ZodString;
+    created_at: z.ZodString;
+    mode: z.ZodEnum<{
+        validate: "validate";
+        "read-only": "read-only";
+        plan: "plan";
+        "apply-sandbox": "apply-sandbox";
+        "apply-approved": "apply-approved";
+    }>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        blocked: "blocked";
+        planned: "planned";
+        failed: "failed";
+        skipped: "skipped";
+        running: "running";
+    }>;
+    command: z.ZodObject<{
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        stdin: z.ZodOptional<z.ZodString>;
+        executable: z.ZodLiteral<"opencode">;
+    }, z.core.$strip>;
+    command_plan_ref: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodDefault<z.ZodString>;
+    exit_code: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    started_at: z.ZodOptional<z.ZodString>;
+    completed_at: z.ZodOptional<z.ZodString>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    structured_output: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    stdout_excerpt: z.ZodOptional<z.ZodString>;
+    stderr_excerpt: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        ref: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        sha256: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    redactions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    risks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        summary: z.ZodString;
+        mitigation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    policy: z.ZodObject<{
+        direct_state_write_allowed: z.ZodLiteral<false>;
+        requires_codesdd_finalize: z.ZodLiteral<true>;
+        raw_secret_output_allowed: z.ZodLiteral<false>;
+        transcript_storage: z.ZodDefault<z.ZodEnum<{
+            forbidden: "forbidden";
+            "redacted-excerpts-only": "redacted-excerpts-only";
+        }>>;
+    }, z.core.$strip>;
+    finalize_intent: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AgentRuntimeProvider = z.infer<typeof agentRuntimeProviderSchema>;
+export type AgentRuntimeMode = z.infer<typeof agentRuntimeModeSchema>;
+export type AgentRuntimeCommandPlanRequest = z.infer<typeof agentRuntimeCommandPlanRequestSchema>;
+export type AgentRuntimeCommandPlan = z.infer<typeof agentRuntimeCommandPlanSchema>;
+export type OpenCodeExecutionEvidence = z.infer<typeof opencodeExecutionEvidenceSchema>;
+export type OpenCodeExecutionEvidenceInput = z.input<typeof opencodeExecutionEvidenceSchema>;
+export declare function buildAgentRuntimeCommandPlan(request: AgentRuntimeCommandPlanRequest, createdAt?: string): AgentRuntimeCommandPlan;
+export declare function buildOpenCodeExecutionEvidence(evidence: OpenCodeExecutionEvidenceInput): OpenCodeExecutionEvidence;
+export declare function buildAgentRuntimeJsonSchemas(): Record<string, unknown>;
+//# sourceMappingURL=agent-runtime-contract.d.ts.map