@testchimp/cli 0.1.18 → 0.1.20

package/dist/cli/program.js

@@ -849,6 +849,133 @@ export function buildCliProgram() {
         const out = await runTool("mark-semantic-tests-distinct", merged, { postMcp });
         console.log(out);
     });
+    program
+        .command("get-requirement-quality-report")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-requirement-quality-report").description)
+        .addOption(jsonInputOption())
+        .option("--subject-type <STORY|SCENARIO>", "STORY for US-<n>, SCENARIO for TS-<n>")
+        .option("--subject-entity-id <id>", "Platform subject entity id")
+        .option("--ordinal-id <n>", "Numeric part of US-<n> or TS-<n>")
+        .action(async (opts) => {
+        const body = {};
+        if (opts.subjectType)
+            body.subjectType = String(opts.subjectType).trim();
+        if (opts.subjectEntityId)
+            body.subjectEntityId = String(opts.subjectEntityId).trim();
+        if (opts.ordinalId != null)
+            body.ordinalId = Number(opts.ordinalId);
+        const merged = mergeBodies(body, opts.jsonInput);
+        if (!merged.subjectType || String(merged.subjectType).trim() === "") {
+            throw new Error("subjectType is required (STORY | SCENARIO)");
+        }
+        const out = await runTool("get-requirement-quality-report", {
+            subjectType: String(merged.subjectType).trim(),
+            ...(merged.subjectEntityId ? { subjectEntityId: String(merged.subjectEntityId).trim() } : {}),
+            ...(merged.ordinalId != null ? { ordinalId: Number(merged.ordinalId) } : {}),
+        }, { postMcp });
+        console.log(out);
+    });
+    program
+        .command("report-requirement-quality-findings")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "report-requirement-quality-findings").description)
+        .addOption(jsonInputOption())
+        .option("--report-file <path>", "Path to RequirementQualityReport JSON (camelCase)")
+        .option("--subject-type <STORY|SCENARIO>", "Merge into report.subject when resolving entity id")
+        .option("--subject-entity-id <id>", "Platform subject entity id (story DB id or scenario UUID)")
+        .option("--ordinal-id <n>", "US-<n> or TS-<n> numeric id; resolves subjectEntityId via get-report")
+        .action(async (opts) => {
+        const body = {};
+        if (opts.reportFile)
+            body.reportFile = String(opts.reportFile);
+        if (opts.subjectType)
+            body.subjectType = String(opts.subjectType).trim();
+        if (opts.subjectEntityId)
+            body.subjectEntityId = String(opts.subjectEntityId).trim();
+        if (opts.ordinalId != null)
+            body.ordinalId = Number(opts.ordinalId);
+        const merged = mergeBodies(body, opts.jsonInput);
+        const out = await runTool("report-requirement-quality-findings", merged, { postMcp });
+        console.log(out);
+    });
+    // Workflow policy + traceability tools (US-181). Prefer --json-input for nested TestLocator.
+    program
+        .command("report-agent-action")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "report-agent-action").description)
+        .addOption(jsonInputOption())
+        .requiredOption("--workflow-id <id>", "Catalog workflow id")
+        .requiredOption("--workflow-execution-id <ulid>", "Stable ULID for the whole run")
+        .requiredOption("--action-type <type>", "CREATED|UPDATED|DELETED|ANALYZED|ACTION_COMPLETED|ACTION_FAILED")
+        .option("--policy-file <name>", "Policy filename")
+        .option("--policy-version <semver>", "Policy version from frontmatter")
+        .option("--git-sha <sha>", "Current HEAD sha")
+        .option("--actor-type <type>", "LOCAL_AGENT|CLOUD_AGENT (or local-agent|cloud-agent)")
+        .option("--user-id <id>", "Optional user id for traceability")
+        .option("--branch-name <name>", "Git branch")
+        .option("--entity-type <type>", "test|story|scenario|issue|workflow|…")
+        .option("--entity-identity <ordinal>", "Project-scoped ordinal id (mutually exclusive with --test-json)")
+        .option("--test-json <json>", "TestLocator JSON (folderPath/fileName/testSuite/testName)")
+        .option("--detail-json <json>", "Optional detail payload")
+        .action(async (opts) => {
+        const body = {
+            workflowId: String(opts.workflowId),
+            workflowExecutionId: String(opts.workflowExecutionId),
+            actionType: String(opts.actionType),
+        };
+        if (opts.policyFile)
+            body.policyFile = String(opts.policyFile);
+        if (opts.policyVersion)
+            body.policyVersion = String(opts.policyVersion);
+        if (opts.gitSha)
+            body.gitSha = String(opts.gitSha);
+        if (opts.actorType)
+            body.actorType = String(opts.actorType);
+        if (opts.userId)
+            body.userId = String(opts.userId);
+        if (opts.branchName)
+            body.branchName = String(opts.branchName);
+        if (opts.entityType)
+            body.entityType = String(opts.entityType);
+        if (opts.entityIdentity)
+            body.entityIdentity = String(opts.entityIdentity);
+        if (opts.testJson)
+            body.test = JSON.parse(String(opts.testJson));
+        if (opts.detailJson)
+            body.detailJson = String(opts.detailJson);
+        const merged = mergeBodies(body, opts.jsonInput);
+        console.log(await runTool("report-agent-action", merged, { postMcp }));
+    });
+    program
+        .command("get-last-run-workflow-detail")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-last-run-workflow-detail").description)
+        .addOption(jsonInputOption())
+        .requiredOption("--workflow-id <id>", "Catalog workflow id")
+        .option("--branch-name <name>", "Optional branch filter (omit for any branch)")
+        .option("--user-id <id>", "Optional per-user last run")
+        .action(async (opts) => {
+        const body = { workflowId: String(opts.workflowId) };
+        if (opts.branchName)
+            body.branchName = String(opts.branchName);
+        if (opts.userId)
+            body.userId = String(opts.userId);
+        const merged = mergeBodies(body, opts.jsonInput);
+        console.log(await runTool("get-last-run-workflow-detail", merged, { postMcp }));
+    });
+    for (const kebab of [
+        "list-workflow-executions",
+        "get-workflow-execution",
+        "get-policy",
+        "list-policies",
+        "list-workflow-catalog",
+    ]) {
+        program
+            .command(kebab)
+            .description(TOOL_DEFINITIONS.find((t) => t.kebab === kebab).description)
+            .addOption(jsonInputOption())
+            .action(async (opts) => {
+            const merged = mergeBodies({}, opts.jsonInput);
+            console.log(await runTool(kebab, merged, { postMcp }));
+        });
+    }
     program.on("--help", () => {
         /* default */
     });

package/dist/core/schemas.d.ts

@@ -711,3 +711,390 @@ export declare const markSemanticTestsDistinctInput: z.ZodObject<{
         testName: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>;
+/** RequirementSubjectType — proto enum names (JsonFormat camelCase on wire). */
+export declare const requirementSubjectTypeSchema: z.ZodEnum<{
+    STORY: "STORY";
+    SCENARIO: "SCENARIO";
+}>;
+/** RequirementFindingSeverity — proto enum names. */
+export declare const requirementFindingSeveritySchema: z.ZodEnum<{
+    CRITICAL: "CRITICAL";
+    MAJOR: "MAJOR";
+    MINOR: "MINOR";
+}>;
+/** RequirementFindingUserState — proto enum names. */
+export declare const requirementFindingUserStateSchema: z.ZodEnum<{
+    ACTIVE: "ACTIVE";
+    IGNORED: "IGNORED";
+    APPLIED: "APPLIED";
+}>;
+/** RequirementQualityReportSource — proto enum names. */
+export declare const requirementQualityReportSourceSchema: z.ZodEnum<{
+    CLOUD: "CLOUD";
+    LOCAL_AGENT: "LOCAL_AGENT";
+}>;
+/** SuggestedFixKind — proto enum names. */
+export declare const suggestedFixKindSchema: z.ZodEnum<{
+    OTHER: "OTHER";
+    REWORD_EXCERPT: "REWORD_EXCERPT";
+    REWRITE_SECTION: "REWRITE_SECTION";
+    ADD_CONTENT: "ADD_CONTENT";
+    CREATE_SCENARIO: "CREATE_SCENARIO";
+    CREATE_STORY: "CREATE_STORY";
+    DELETE_SCENARIO: "DELETE_SCENARIO";
+    DELETE_STORY: "DELETE_STORY";
+    LINK_OR_UNLINK: "LINK_OR_UNLINK";
+}>;
+/** TextReplacement (requirement_quality.proto) — camelCase wire shape. */
+export declare const textReplacementSchema: z.ZodObject<{
+    originalExcerpt: z.ZodOptional<z.ZodString>;
+    suggestedText: z.ZodOptional<z.ZodString>;
+    contextBefore: z.ZodOptional<z.ZodString>;
+    contextAfter: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** SuggestedFix (requirement_quality.proto). isDestructive is derived server-side from kind. */
+export declare const suggestedFixSchema: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodEnum<{
+        OTHER: "OTHER";
+        REWORD_EXCERPT: "REWORD_EXCERPT";
+        REWRITE_SECTION: "REWRITE_SECTION";
+        ADD_CONTENT: "ADD_CONTENT";
+        CREATE_SCENARIO: "CREATE_SCENARIO";
+        CREATE_STORY: "CREATE_STORY";
+        DELETE_SCENARIO: "DELETE_SCENARIO";
+        DELETE_STORY: "DELETE_STORY";
+        LINK_OR_UNLINK: "LINK_OR_UNLINK";
+    }>>;
+    isDestructive: z.ZodOptional<z.ZodBoolean>;
+    targetEntityType: z.ZodOptional<z.ZodString>;
+    targetOrdinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    summary: z.ZodOptional<z.ZodString>;
+    agentPrompt: z.ZodOptional<z.ZodString>;
+    replacements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        originalExcerpt: z.ZodOptional<z.ZodString>;
+        suggestedText: z.ZodOptional<z.ZodString>;
+        contextBefore: z.ZodOptional<z.ZodString>;
+        contextAfter: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    rationale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** RequirementQualityFinding (requirement_quality.proto). */
+export declare const requirementQualityFindingSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    fingerprint: z.ZodOptional<z.ZodString>;
+    analyst: z.ZodOptional<z.ZodString>;
+    severity: z.ZodOptional<z.ZodEnum<{
+        CRITICAL: "CRITICAL";
+        MAJOR: "MAJOR";
+        MINOR: "MINOR";
+    }>>;
+    confidence: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    title: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodString>;
+    suggestedFix: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodEnum<{
+            OTHER: "OTHER";
+            REWORD_EXCERPT: "REWORD_EXCERPT";
+            REWRITE_SECTION: "REWRITE_SECTION";
+            ADD_CONTENT: "ADD_CONTENT";
+            CREATE_SCENARIO: "CREATE_SCENARIO";
+            CREATE_STORY: "CREATE_STORY";
+            DELETE_SCENARIO: "DELETE_SCENARIO";
+            DELETE_STORY: "DELETE_STORY";
+            LINK_OR_UNLINK: "LINK_OR_UNLINK";
+        }>>;
+        isDestructive: z.ZodOptional<z.ZodBoolean>;
+        targetEntityType: z.ZodOptional<z.ZodString>;
+        targetOrdinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        summary: z.ZodOptional<z.ZodString>;
+        agentPrompt: z.ZodOptional<z.ZodString>;
+        replacements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            originalExcerpt: z.ZodOptional<z.ZodString>;
+            suggestedText: z.ZodOptional<z.ZodString>;
+            contextBefore: z.ZodOptional<z.ZodString>;
+            contextAfter: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        rationale: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    userState: z.ZodOptional<z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        IGNORED: "IGNORED";
+        APPLIED: "APPLIED";
+    }>>;
+}, z.core.$strip>;
+/** RequirementQualityMetrics (requirement_quality.proto) — scores 0-100, counts among ACTIVE findings. */
+export declare const requirementQualityMetricsSchema: z.ZodObject<{
+    overall: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    clarity: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    completeness: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    testability: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    consistency: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    ambiguityRisk: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    scenarioCoverage: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    criticalCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    majorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    minorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/** RequirementQualitySubject (requirement_quality.proto). subjectEntityId is the platform-internal id. */
+export declare const requirementQualitySubjectSchema: z.ZodObject<{
+    subjectType: z.ZodOptional<z.ZodEnum<{
+        STORY: "STORY";
+        SCENARIO: "SCENARIO";
+    }>>;
+    subjectEntityId: z.ZodOptional<z.ZodString>;
+    ordinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** RequirementQualityReport (requirement_quality.proto) — full upload body shape. */
+export declare const requirementQualityReportSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodObject<{
+        subjectType: z.ZodOptional<z.ZodEnum<{
+            STORY: "STORY";
+            SCENARIO: "SCENARIO";
+        }>>;
+        subjectEntityId: z.ZodOptional<z.ZodString>;
+        ordinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    source: z.ZodOptional<z.ZodEnum<{
+        CLOUD: "CLOUD";
+        LOCAL_AGENT: "LOCAL_AGENT";
+    }>>;
+    metrics: z.ZodOptional<z.ZodObject<{
+        overall: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        clarity: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        completeness: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        testability: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        consistency: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        ambiguityRisk: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        scenarioCoverage: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        criticalCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        majorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        minorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
+    findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        analyst: z.ZodOptional<z.ZodString>;
+        severity: z.ZodOptional<z.ZodEnum<{
+            CRITICAL: "CRITICAL";
+            MAJOR: "MAJOR";
+            MINOR: "MINOR";
+        }>>;
+        confidence: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        title: z.ZodOptional<z.ZodString>;
+        detail: z.ZodOptional<z.ZodString>;
+        suggestedFix: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodEnum<{
+                OTHER: "OTHER";
+                REWORD_EXCERPT: "REWORD_EXCERPT";
+                REWRITE_SECTION: "REWRITE_SECTION";
+                ADD_CONTENT: "ADD_CONTENT";
+                CREATE_SCENARIO: "CREATE_SCENARIO";
+                CREATE_STORY: "CREATE_STORY";
+                DELETE_SCENARIO: "DELETE_SCENARIO";
+                DELETE_STORY: "DELETE_STORY";
+                LINK_OR_UNLINK: "LINK_OR_UNLINK";
+            }>>;
+            isDestructive: z.ZodOptional<z.ZodBoolean>;
+            targetEntityType: z.ZodOptional<z.ZodString>;
+            targetOrdinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            summary: z.ZodOptional<z.ZodString>;
+            agentPrompt: z.ZodOptional<z.ZodString>;
+            replacements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                originalExcerpt: z.ZodOptional<z.ZodString>;
+                suggestedText: z.ZodOptional<z.ZodString>;
+                contextBefore: z.ZodOptional<z.ZodString>;
+                contextAfter: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            rationale: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        userState: z.ZodOptional<z.ZodEnum<{
+            ACTIVE: "ACTIVE";
+            IGNORED: "IGNORED";
+            APPLIED: "APPLIED";
+        }>>;
+    }, z.core.$strip>>>;
+    createdAtMillis: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    jobId: z.ZodOptional<z.ZodString>;
+    contentFingerprint: z.ZodOptional<z.ZodString>;
+    scoresUpdatedAtMillis: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const getRequirementQualityReportInput: z.ZodObject<{
+    subjectType: z.ZodEnum<{
+        STORY: "STORY";
+        SCENARIO: "SCENARIO";
+    }>;
+    subjectEntityId: z.ZodOptional<z.ZodString>;
+    ordinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const reportRequirementQualityFindingsInput: z.ZodObject<{
+    report: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodObject<{
+            subjectType: z.ZodOptional<z.ZodEnum<{
+                STORY: "STORY";
+                SCENARIO: "SCENARIO";
+            }>>;
+            subjectEntityId: z.ZodOptional<z.ZodString>;
+            ordinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        source: z.ZodOptional<z.ZodEnum<{
+            CLOUD: "CLOUD";
+            LOCAL_AGENT: "LOCAL_AGENT";
+        }>>;
+        metrics: z.ZodOptional<z.ZodObject<{
+            overall: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            clarity: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            completeness: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            testability: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            consistency: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            ambiguityRisk: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            scenarioCoverage: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            criticalCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            majorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            minorCount: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strip>>;
+        findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            fingerprint: z.ZodOptional<z.ZodString>;
+            analyst: z.ZodOptional<z.ZodString>;
+            severity: z.ZodOptional<z.ZodEnum<{
+                CRITICAL: "CRITICAL";
+                MAJOR: "MAJOR";
+                MINOR: "MINOR";
+            }>>;
+            confidence: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            title: z.ZodOptional<z.ZodString>;
+            detail: z.ZodOptional<z.ZodString>;
+            suggestedFix: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodOptional<z.ZodEnum<{
+                    OTHER: "OTHER";
+                    REWORD_EXCERPT: "REWORD_EXCERPT";
+                    REWRITE_SECTION: "REWRITE_SECTION";
+                    ADD_CONTENT: "ADD_CONTENT";
+                    CREATE_SCENARIO: "CREATE_SCENARIO";
+                    CREATE_STORY: "CREATE_STORY";
+                    DELETE_SCENARIO: "DELETE_SCENARIO";
+                    DELETE_STORY: "DELETE_STORY";
+                    LINK_OR_UNLINK: "LINK_OR_UNLINK";
+                }>>;
+                isDestructive: z.ZodOptional<z.ZodBoolean>;
+                targetEntityType: z.ZodOptional<z.ZodString>;
+                targetOrdinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                summary: z.ZodOptional<z.ZodString>;
+                agentPrompt: z.ZodOptional<z.ZodString>;
+                replacements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    originalExcerpt: z.ZodOptional<z.ZodString>;
+                    suggestedText: z.ZodOptional<z.ZodString>;
+                    contextBefore: z.ZodOptional<z.ZodString>;
+                    contextAfter: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                rationale: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            userState: z.ZodOptional<z.ZodEnum<{
+                ACTIVE: "ACTIVE";
+                IGNORED: "IGNORED";
+                APPLIED: "APPLIED";
+            }>>;
+        }, z.core.$strip>>>;
+        createdAtMillis: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        jobId: z.ZodOptional<z.ZodString>;
+        contentFingerprint: z.ZodOptional<z.ZodString>;
+        scoresUpdatedAtMillis: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>>;
+    reportFile: z.ZodOptional<z.ZodString>;
+    subjectType: z.ZodOptional<z.ZodEnum<{
+        STORY: "STORY";
+        SCENARIO: "SCENARIO";
+    }>>;
+    subjectEntityId: z.ZodOptional<z.ZodString>;
+    ordinalId: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const agentActorTypeSchema: z.ZodEnum<{
+    LOCAL_AGENT: "LOCAL_AGENT";
+    CLOUD_AGENT: "CLOUD_AGENT";
+    "local-agent": "local-agent";
+    "cloud-agent": "cloud-agent";
+}>;
+export declare const agentActionTypeSchema: z.ZodEnum<{
+    failed: "failed";
+    CREATED: "CREATED";
+    UPDATED: "UPDATED";
+    DELETED: "DELETED";
+    ANALYZED: "ANALYZED";
+    ACTION_COMPLETED: "ACTION_COMPLETED";
+    ACTION_FAILED: "ACTION_FAILED";
+    created: "created";
+    updated: "updated";
+    deleted: "deleted";
+    analyzed: "analyzed";
+    completed: "completed";
+    action_completed: "action_completed";
+    action_failed: "action_failed";
+}>;
+export declare const reportAgentActionInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    workflowExecutionId: z.ZodString;
+    policyFile: z.ZodOptional<z.ZodString>;
+    policyVersion: z.ZodOptional<z.ZodString>;
+    gitSha: z.ZodOptional<z.ZodString>;
+    actorType: z.ZodOptional<z.ZodEnum<{
+        LOCAL_AGENT: "LOCAL_AGENT";
+        CLOUD_AGENT: "CLOUD_AGENT";
+        "local-agent": "local-agent";
+        "cloud-agent": "cloud-agent";
+    }>>;
+    userId: z.ZodOptional<z.ZodString>;
+    branchName: z.ZodOptional<z.ZodString>;
+    entityType: z.ZodOptional<z.ZodString>;
+    entityIdentity: z.ZodOptional<z.ZodString>;
+    test: z.ZodOptional<z.ZodObject<{
+        folderPath: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fileName: z.ZodString;
+        testSuite: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        testName: z.ZodString;
+    }, z.core.$strip>>;
+    actionType: z.ZodEnum<{
+        failed: "failed";
+        CREATED: "CREATED";
+        UPDATED: "UPDATED";
+        DELETED: "DELETED";
+        ANALYZED: "ANALYZED";
+        ACTION_COMPLETED: "ACTION_COMPLETED";
+        ACTION_FAILED: "ACTION_FAILED";
+        created: "created";
+        updated: "updated";
+        deleted: "deleted";
+        analyzed: "analyzed";
+        completed: "completed";
+        action_completed: "action_completed";
+        action_failed: "action_failed";
+    }>;
+    detailJson: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getLastRunWorkflowDetailInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    branchName: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listWorkflowExecutionsInput: z.ZodObject<{
+    workflowId: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare const getWorkflowExecutionInput: z.ZodObject<{
+    workflowExecutionId: z.ZodString;
+    includeActions: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const getPolicyInput: z.ZodObject<{
+    policyFileName: z.ZodString;
+}, z.core.$strip>;
+export declare const listPoliciesInput: z.ZodObject<{
+    workflowId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listWorkflowCatalogInput: z.ZodObject<{}, z.core.$strip>;

package/dist/core/schemas.js

@@ -377,3 +377,191 @@ export const markSemanticTestsDistinctInput = z.object({
     focusTest: testLocatorSchema,
     distinctTest: testLocatorSchema,
 });
+/** RequirementSubjectType — proto enum names (JsonFormat camelCase on wire). */
+export const requirementSubjectTypeSchema = z.enum(["STORY", "SCENARIO"]);
+/** RequirementFindingSeverity — proto enum names. */
+export const requirementFindingSeveritySchema = z.enum(["CRITICAL", "MAJOR", "MINOR"]);
+/** RequirementFindingUserState — proto enum names. */
+export const requirementFindingUserStateSchema = z.enum(["ACTIVE", "IGNORED", "APPLIED"]);
+/** RequirementQualityReportSource — proto enum names. */
+export const requirementQualityReportSourceSchema = z.enum(["CLOUD", "LOCAL_AGENT"]);
+/** SuggestedFixKind — proto enum names. */
+export const suggestedFixKindSchema = z.enum([
+    "REWORD_EXCERPT",
+    "REWRITE_SECTION",
+    "ADD_CONTENT",
+    "CREATE_SCENARIO",
+    "CREATE_STORY",
+    "DELETE_SCENARIO",
+    "DELETE_STORY",
+    "LINK_OR_UNLINK",
+    "OTHER",
+]);
+/** TextReplacement (requirement_quality.proto) — camelCase wire shape. */
+export const textReplacementSchema = z.object({
+    originalExcerpt: z.string().optional(),
+    suggestedText: z.string().optional(),
+    contextBefore: z.string().optional(),
+    contextAfter: z.string().optional(),
+});
+/** SuggestedFix (requirement_quality.proto). isDestructive is derived server-side from kind. */
+export const suggestedFixSchema = z.object({
+    kind: suggestedFixKindSchema.optional(),
+    isDestructive: z.boolean().optional(),
+    /** "STORY" | "SCENARIO" — target of the fix (may differ from the finding's own subject). */
+    targetEntityType: z.string().optional(),
+    targetOrdinalId: z.coerce.number().int().optional(),
+    summary: z.string().optional(),
+    agentPrompt: z.string().optional(),
+    replacements: z.array(textReplacementSchema).optional(),
+    rationale: z.string().optional(),
+});
+/** RequirementQualityFinding (requirement_quality.proto). */
+export const requirementQualityFindingSchema = z.object({
+    id: z.string().optional(),
+    fingerprint: z.string().optional(),
+    analyst: z.string().optional(),
+    severity: requirementFindingSeveritySchema.optional(),
+    confidence: z.coerce.number().int().optional(),
+    title: z.string().optional(),
+    detail: z.string().optional(),
+    suggestedFix: suggestedFixSchema.optional(),
+    /** Omit (defaults ACTIVE server-side) for new findings; set explicitly to carry forward IGNORED/APPLIED. */
+    userState: requirementFindingUserStateSchema.optional(),
+});
+/** RequirementQualityMetrics (requirement_quality.proto) — scores 0-100, counts among ACTIVE findings. */
+export const requirementQualityMetricsSchema = z.object({
+    overall: z.coerce.number().int().optional(),
+    clarity: z.coerce.number().int().optional(),
+    completeness: z.coerce.number().int().optional(),
+    testability: z.coerce.number().int().optional(),
+    consistency: z.coerce.number().int().optional(),
+    ambiguityRisk: z.coerce.number().int().optional(),
+    scenarioCoverage: z.coerce.number().int().optional(),
+    criticalCount: z.coerce.number().int().optional(),
+    majorCount: z.coerce.number().int().optional(),
+    minorCount: z.coerce.number().int().optional(),
+});
+/** RequirementQualitySubject (requirement_quality.proto). subjectEntityId is the platform-internal id. */
+export const requirementQualitySubjectSchema = z.object({
+    subjectType: requirementSubjectTypeSchema.optional(),
+    subjectEntityId: z.string().optional(),
+    ordinalId: z.coerce.number().int().optional(),
+    title: z.string().optional(),
+});
+/** RequirementQualityReport (requirement_quality.proto) — full upload body shape. */
+export const requirementQualityReportSchema = z.object({
+    id: z.string().optional(),
+    projectId: z.string().optional(),
+    subject: requirementQualitySubjectSchema.optional(),
+    source: requirementQualityReportSourceSchema.optional(),
+    metrics: requirementQualityMetricsSchema.optional(),
+    findings: z.array(requirementQualityFindingSchema).optional(),
+    createdAtMillis: z.coerce.number().optional(),
+    jobId: z.string().optional(),
+    contentFingerprint: z.string().optional(),
+    scoresUpdatedAtMillis: z.coerce.number().optional(),
+});
+const requirementSubjectRefinement = (v, ctx) => {
+    const entityId = (v.subjectEntityId ?? "").trim();
+    const ordinal = v.ordinalId;
+    if (entityId === "" && (ordinal == null || ordinal <= 0)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Provide subjectEntityId or ordinalId",
+        });
+    }
+};
+export const getRequirementQualityReportInput = z
+    .object({
+    subjectType: requirementSubjectTypeSchema,
+    subjectEntityId: z.string().optional(),
+    ordinalId: z.coerce.number().int().positive().optional(),
+})
+    .superRefine(requirementSubjectRefinement);
+export const reportRequirementQualityFindingsInput = z
+    .object({
+    /** Full RequirementQualityReport JSON object (camelCase, requirement_quality.proto). */
+    report: requirementQualityReportSchema.optional(),
+    /** Path to RequirementQualityReport JSON file. */
+    reportFile: z.string().optional(),
+    /** Convenience: merged into report.subject when report lacks subjectEntityId. */
+    subjectType: requirementSubjectTypeSchema.optional(),
+    subjectEntityId: z.string().optional(),
+    ordinalId: z.coerce.number().int().positive().optional(),
+})
+    .superRefine((v, ctx) => {
+    const hasReport = v.report != null && Object.keys(v.report).length > 0;
+    const hasFile = (v.reportFile ?? "").trim() !== "";
+    if (!hasReport && !hasFile) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Provide report object, reportFile path, or full body via --json-input",
+        });
+    }
+});
+export const agentActorTypeSchema = z.enum(["LOCAL_AGENT", "CLOUD_AGENT", "local-agent", "cloud-agent"]);
+export const agentActionTypeSchema = z.enum([
+    "CREATED",
+    "UPDATED",
+    "DELETED",
+    "ANALYZED",
+    "ACTION_COMPLETED",
+    "ACTION_FAILED",
+    "created",
+    "updated",
+    "deleted",
+    "analyzed",
+    "completed",
+    "failed",
+    "action_completed",
+    "action_failed",
+]);
+export const reportAgentActionInput = z
+    .object({
+    workflowId: z.string().min(1),
+    workflowExecutionId: z.string().min(1),
+    policyFile: z.string().optional(),
+    policyVersion: z.string().optional(),
+    gitSha: z.string().optional(),
+    actorType: agentActorTypeSchema.optional(),
+    userId: z.string().optional(),
+    branchName: z.string().optional(),
+    entityType: z.string().optional(),
+    /** Project-scoped ordinal id (or explicitly provided execution/batch id). Mutually exclusive with `test`. */
+    entityIdentity: z.string().optional(),
+    /** SmartTest TestLocator. Mutually exclusive with `entityIdentity`. */
+    test: testLocatorSchema.optional(),
+    actionType: agentActionTypeSchema,
+    detailJson: z.string().optional(),
+})
+    .superRefine((val, ctx) => {
+    if (val.test && val.entityIdentity) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Provide either test (TestLocator) or entityIdentity (ordinal), not both",
+            path: ["test"],
+        });
+    }
+});
+export const getLastRunWorkflowDetailInput = z.object({
+    workflowId: z.string().min(1),
+    branchName: z.string().optional(),
+    userId: z.string().optional(),
+});
+export const listWorkflowExecutionsInput = z.object({
+    workflowId: z.string().optional(),
+    limit: z.coerce.number().int().positive().max(200).optional(),
+    offset: z.coerce.number().int().nonnegative().optional(),
+});
+export const getWorkflowExecutionInput = z.object({
+    workflowExecutionId: z.string().min(1),
+    includeActions: z.boolean().optional(),
+});
+export const getPolicyInput = z.object({
+    policyFileName: z.string().min(1),
+});
+export const listPoliciesInput = z.object({
+    workflowId: z.string().optional(),
+});
+export const listWorkflowCatalogInput = z.object({});

package/dist/core/tools.js

@@ -85,6 +85,43 @@ function listExecutionBody(args) {
         body.offset = args.offset;
     return body;
 }
+function requirementQualitySubjectBody(subjectType, opts) {
+    const body = { subjectType };
+    const entityId = (opts.subjectEntityId ?? "").trim();
+    if (entityId !== "")
+        body.subjectEntityId = entityId;
+    if (opts.ordinalId != null && opts.ordinalId > 0)
+        body.ordinalId = opts.ordinalId;
+    return body;
+}
+/** Resolve platform subjectEntityId from explicit id or get-requirement-quality-report via ordinal. */
+async function resolveRequirementSubjectEntityId(postMcp, subjectType, opts) {
+    const explicit = (opts.subjectEntityId ?? "").trim();
+    if (explicit !== "")
+        return explicit;
+    if (opts.ordinalId == null || opts.ordinalId <= 0) {
+        throw new Error("Provide subjectEntityId or ordinalId");
+    }
+    const json = await postMcp("/api/mcp/get_requirement_quality_report", requirementQualitySubjectBody(subjectType, { ordinalId: opts.ordinalId }));
+    const parsed = JSON.parse(json);
+    const resolved = (parsed.report?.subject?.subjectEntityId ?? "").trim();
+    if (resolved !== "")
+        return resolved;
+    throw new Error(`Cannot resolve subjectEntityId for ${subjectType} ordinal ${opts.ordinalId}. ` +
+        "Provide --subject-entity-id, or confirm the story/scenario ordinal exists in this project " +
+        "(get-requirement-quality-report resolves entity id by ordinal even when no prior report exists).");
+}
+async function loadRequirementQualityReportJson(args) {
+    if (args.report != null && Object.keys(args.report).length > 0) {
+        return { ...args.report };
+    }
+    if (args.reportFile != null && args.reportFile.trim() !== "") {
+        const { readFile } = await import("node:fs/promises");
+        const raw = await readFile(args.reportFile.trim(), "utf8");
+        return JSON.parse(raw);
+    }
+    return {};
+}
 export const TOOL_DEFINITIONS = [
     {
         kebab: "get-requirement-coverage",
@@ -691,6 +728,176 @@ export const TOOL_DEFINITIONS = [
             });
         },
     },
+    {
+        kebab: "get-requirement-quality-report",
+        description: "Fetch the stored requirement quality report (metrics + findings with user states) for a user story or test scenario. " +
+            "Use before local DeFOSPAM to dedupe: do not re-report findings already IGNORED or APPLIED (match by fingerprint). " +
+            "Pass subjectType STORY|SCENARIO plus subjectEntityId or ordinalId (numeric part of US-<n> / TS-<n>). " +
+            "When no prior report exists, response still includes report.subject with resolved subjectEntityId.",
+        inputSchema: S.getRequirementQualityReportInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            return postMcp("/api/mcp/get_requirement_quality_report", requirementQualitySubjectBody(a.subjectType, {
+                subjectEntityId: a.subjectEntityId,
+                ordinalId: a.ordinalId,
+            }));
+        },
+    },
+    {
+        kebab: "report-requirement-quality-findings",
+        description: "Upload a DeFOSPAM / requirement quality analysis report for a user story or test scenario (local-agent path). " +
+            "Pass full RequirementQualityReport JSON via --report-file or --json-input {\"report\":{...}}. " +
+            "report.subject.subjectEntityId is required; use --subject-type + --ordinal-id to resolve via get-requirement-quality-report, " +
+            "or set subjectEntityId explicitly. Backend merges IGNORED/APPLIED findings carry-forward on re-report.",
+        inputSchema: S.reportRequirementQualityFindingsInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const report = await loadRequirementQualityReportJson(a);
+            const subjectRaw = (report.subject ?? {});
+            const subjectType = (a.subjectType ?? subjectRaw.subjectType);
+            const ordinalId = a.ordinalId ??
+                (typeof subjectRaw.ordinalId === "number" ? subjectRaw.ordinalId : undefined);
+            let subjectEntityId = (a.subjectEntityId ?? (typeof subjectRaw.subjectEntityId === "string" ? subjectRaw.subjectEntityId : "")).trim();
+            if (subjectEntityId === "" && subjectType != null) {
+                subjectEntityId = await resolveRequirementSubjectEntityId(postMcp, subjectType, {
+                    ordinalId,
+                });
+            }
+            if (subjectEntityId === "") {
+                throw new Error("report.subject.subjectEntityId is required (set in report JSON, --subject-entity-id, or resolvable via --ordinal-id)");
+            }
+            const mergedSubject = {
+                ...subjectRaw,
+                ...(subjectType != null ? { subjectType } : {}),
+                subjectEntityId,
+                ...(ordinalId != null ? { ordinalId } : {}),
+            };
+            report.subject = mergedSubject;
+            return postMcp("/api/mcp/report_requirement_quality_findings", { report });
+        },
+    },
+    {
+        kebab: "report-agent-action",
+        description: "Report a mutating agent action under a stable workflow-execution-id (ULID). " +
+            "First call for an id creates the workflow_executions row; later calls append agent_actions. " +
+            "Identity: pass `test` (TestLocator: folderPath/fileName/testSuite/testName) for SmartTests, " +
+            "or `entityIdentity` as a project-scoped ordinal id for stories/scenarios/issues " +
+            "(or an execution/batch id only when the prompt explicitly provided it). Do not use platform UUIDs.",
+        inputSchema: S.reportAgentActionInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const actorRaw = (a.actorType ?? "local-agent").toString();
+            const actorType = actorRaw.toUpperCase().replace(/-/g, "_") === "CLOUD_AGENT" ? "CLOUD_AGENT" : "LOCAL_AGENT";
+            const actionNorm = a.actionType.toString().toUpperCase().replace(/-/g, "_");
+            let actionType = actionNorm;
+            if (actionNorm === "COMPLETED" || actionNorm === "ACTION_COMPLETED") {
+                actionType = "ACTION_COMPLETED";
+            }
+            else if (actionNorm === "FAILED" || actionNorm === "ACTION_FAILED") {
+                actionType = "ACTION_FAILED";
+            }
+            const body = {
+                workflowId: a.workflowId,
+                workflowExecutionId: a.workflowExecutionId,
+                actionType,
+                actorType,
+            };
+            if (a.policyFile)
+                body.policyFile = a.policyFile;
+            if (a.policyVersion)
+                body.policyVersion = a.policyVersion;
+            if (a.gitSha)
+                body.gitSha = a.gitSha;
+            if (a.userId)
+                body.userId = a.userId;
+            else if (process.env.TESTCHIMP_USER_ID)
+                body.userId = process.env.TESTCHIMP_USER_ID;
+            if (a.branchName)
+                body.branchName = a.branchName;
+            if (a.entityType)
+                body.entityType = a.entityType;
+            if (a.test) {
+                body.test = a.test;
+            }
+            else if (a.entityIdentity) {
+                body.entityIdentity = a.entityIdentity;
+            }
+            if (a.detailJson)
+                body.detailJson = a.detailJson;
+            return postMcp("/api/mcp/report_agent_action", body);
+        },
+    },
+    {
+        kebab: "get-last-run-workflow-detail",
+        description: "Fetch the last workflow execution for a workflow-id on a branch (optional userId for per-user last run). " +
+            "Used for since-last-run scoping.",
+        inputSchema: S.getLastRunWorkflowDetailInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const body = {
+                workflowId: a.workflowId,
+                branchName: a.branchName,
+            };
+            if (a.userId)
+                body.userId = a.userId;
+            return postMcp("/api/mcp/get_last_run_workflow_detail", body);
+        },
+    },
+    {
+        kebab: "list-workflow-executions",
+        description: "List recent workflow executions for the project, optionally filtered by workflowId.",
+        inputSchema: S.listWorkflowExecutionsInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const body = {};
+            if (a.workflowId)
+                body.workflowId = a.workflowId;
+            if (a.limit != null)
+                body.limit = a.limit;
+            if (a.offset != null)
+                body.offset = a.offset;
+            return postMcp("/api/mcp/list_workflow_executions", body);
+        },
+    },
+    {
+        kebab: "get-workflow-execution",
+        description: "Get a workflow execution by id; pass includeActions=true for the action timeline.",
+        inputSchema: S.getWorkflowExecutionInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            return postMcp("/api/mcp/get_workflow_execution", {
+                workflowExecutionId: a.workflowExecutionId,
+                includeActions: a.includeActions ?? true,
+            });
+        },
+    },
+    {
+        kebab: "get-policy",
+        description: "Fetch a workflow policy file by name (e.g. run-qa.policy.md) from the platform POLICY_FILE store.",
+        inputSchema: S.getPolicyInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            return postMcp("/api/mcp/get_policy", { policyFileName: a.policyFileName });
+        },
+    },
+    {
+        kebab: "list-policies",
+        description: "List policy files for an optional workflow-id. Marks isDefault when filename is <workflow-id>.policy.md.",
+        inputSchema: S.listPoliciesInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const body = {};
+            if (a.workflowId)
+                body.workflowId = a.workflowId;
+            return postMcp("/api/mcp/list_policies", body);
+        },
+    },
+    {
+        kebab: "list-workflow-catalog",
+        description: "List supported TestChimp workflows with Active / Disabled / Missing Config status for the project.",
+        inputSchema: S.listWorkflowCatalogInput,
+        execute: async (_args, { postMcp }) => postMcp("/api/mcp/list_workflow_catalog", {}),
+    },
 ];
 const TOOL_BY_KEBAB = new Map(TOOL_DEFINITIONS.map((t) => [t.kebab, t]));
 export function getToolDefinition(kebab) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testchimp/cli",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "TestChimp CLI and MCP server — coverage, plans, EaaS, TrueCoverage (calls /api/mcp/*)",
   "type": "module",
   "main": "dist/bin/testchimp.js",