@devtrack-solution/codesdd 1.2.3 → 1.2.4-rc3

package/dist/core/completions/command-registry.js

@@ -449,6 +449,51 @@ const COMMAND_METADATA_OVERRIDES = [
                 description: 'Configure workflow profile (interactive picker or preset shortcut)',
                 flags: [],
             },
+            {
+                name: 'redis',
+                description: 'Inspect and operate the optional Redis runtime backend',
+                flags: [],
+                subcommands: [
+                    {
+                        name: 'status',
+                        description: 'Show Redis runtime status',
+                        flags: [
+                            COMMON_FLAGS.json,
+                        ],
+                    },
+                    {
+                        name: 'ping',
+                        description: 'Ping Redis using the effective CodeSDD configuration',
+                        flags: [
+                            COMMON_FLAGS.json,
+                        ],
+                    },
+                    {
+                        name: 'bench',
+                        description: 'Run a short redacted Redis latency benchmark',
+                        flags: [
+                            COMMON_FLAGS.json,
+                            {
+                                name: 'iterations',
+                                description: 'Number of benchmark iterations',
+                                takesValue: true,
+                            },
+                        ],
+                    },
+                    {
+                        name: 'flush-namespace',
+                        description: 'Delete only keys under the effective CodeSDD Redis namespace',
+                        flags: [
+                            COMMON_FLAGS.json,
+                            {
+                                name: 'yes',
+                                short: 'y',
+                                description: 'Confirm namespace-scoped deletion',
+                            },
+                        ],
+                    },
+                ],
+            },
         ],
     },
     {

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

@@ -15,6 +15,23 @@ export declare const GlobalConfigSchema: z.ZodObject<{
         both: "both";
     }>>>;
     workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    redis: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodString>;
+        url_env: z.ZodOptional<z.ZodString>;
+        namespace: z.ZodOptional<z.ZodString>;
+        tls: z.ZodOptional<z.ZodBoolean>;
+        connect_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        command_timeout_ms: z.ZodOptional<z.ZodNumber>;
+        max_retries: z.ZodOptional<z.ZodNumber>;
+        fallback: z.ZodOptional<z.ZodEnum<{
+            filesystem: "filesystem";
+            none: "none";
+        }>>;
+        cache_default_ttl_ms: z.ZodOptional<z.ZodNumber>;
+        lock_ttl_ms: z.ZodOptional<z.ZodNumber>;
+        stream_max_len: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$loose>;
 export type GlobalConfigType = z.infer<typeof GlobalConfigSchema>;
 /**
@@ -84,5 +101,5 @@ export declare function validateConfig(config: unknown): {
     error?: string;
 };
 export declare function isSensitiveConfigPath(path: string): boolean;
-export declare function redactConfigSecrets(value: unknown): unknown;
+export declare function redactConfigSecrets(value: unknown, parentPath?: string): unknown;
 //# sourceMappingURL=config-schema.d.ts.map

package/dist/core/config-schema.js

@@ -20,6 +20,22 @@ 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(),
 })
     .passthrough();
 /**
@@ -30,7 +46,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']);
 const SENSITIVE_KEY_TOKENS = ['key', 'secret', 'token', 'password', 'credential', 'private', 'auth'];
 /**
  * Validate a config key path for CLI set operations.
@@ -51,6 +67,29 @@ 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 (rawKeys.length > 1) {
         return { valid: false, reason: `"${rootKey}" does not support nested keys` };
     }
@@ -216,22 +255,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/global-config.d.ts

@@ -7,11 +7,27 @@ 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 interface GlobalConfig {
     featureFlags?: Record<string, boolean>;
     profile?: Profile;
     delivery?: Delivery;
     workflows?: string[];
+    redis?: RedisGlobalConfig;
 }
 export declare function parseTomlContent(content: string): Record<string, unknown>;
 export declare function stringifyTomlContent(value: Record<string, unknown>): string;

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

@@ -8,10 +8,10 @@ declare const agentProviderSchema: z.ZodEnum<{
     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";
@@ -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";
@@ -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";
@@ -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";
@@ -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<{
+    codex: "codex";
+    opencode: "opencode";
+    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<{
+        codex: "codex";
+        opencode: "opencode";
+        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<{
+            codex: "codex";
+            opencode: "opencode";
+            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<{
+        codex: "codex";
+        opencode: "opencode";
+        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