Index: /trunk/ippTools/src/dettool.c
===================================================================
--- /trunk/ippTools/src/dettool.c	(revision 11087)
+++ /trunk/ippTools/src/dettool.c	(revision 11088)
@@ -167,4 +167,5 @@
         " WHERE"
         "    detInputExp.exp_tag IS NULL"
+        "    AND rawExp.obstype != 'object'"
     );
 
@@ -188,5 +189,4 @@
     }
     if (!psArrayLength(output)) {
-        // XXX check psError here
         psError(PS_ERR_UNKNOWN, false, "no pending rawExp rows found");
         psFree(output);
@@ -1717,4 +1717,11 @@
     }
 
+    // default values
+    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
+        return false;
+    }
+
     psArray *rawImfiles = rawImfileSelectRowObjects(config->dbh, where, 0);
     psFree(where);
@@ -1723,4 +1730,5 @@
         return false;
     }
+
 
     // create a new detProcessedImfile object
@@ -1735,5 +1743,6 @@
         bg_mean_stdev,
         b1_uri,
-        b2_uri
+        b2_uri,
+        code
     );
     psFree(rawImfiles);
@@ -1950,4 +1959,11 @@
     }
 
+    // default values
+    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
+        return false;
+    }
+
     psString query = psStringCopy(
         " SELECT DISTINCT"
@@ -2015,5 +2031,6 @@
         bg_mean_stdev,
         b1_uri,
-        b2_uri
+        b2_uri,
+        code
     );
 
@@ -2033,4 +2050,17 @@
 {
     PS_ASSERT_PTR_NON_NULL(config, false);
+
+    bool status = false;
+    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
+        return false;
+    }
+
+    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
+        return false;
+    }
 
     psString query = psStringCopy("SELECT * FROM detProcessedExp");
@@ -2040,4 +2070,19 @@
         psStringAppend(&query, " %s", whereClause);
         psFree(whereClause);
+    }
+
+    if (faulted) {
+        // list only faulted rows
+        psStringAppend(&query, " %s", "AND detProcessedExp.fault != 0");
+    } else {
+        // don't list faulted rows
+        psStringAppend(&query, " %s", "AND detProcessedExp.fault = 0");
+    }
+
+    // treat limit == 0 as "no limit"
+    if (limit) {
+        psString limitString = psDBGenerateLimitSQL(limit);
+        psStringAppend(&query, " %s", limitString);
+        psFree(limitString);
     }
 
@@ -2206,4 +2251,17 @@
     PS_ASSERT_PTR_NON_NULL(config, false);
 
+    bool status = false;
+    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
+        return false;
+    }
+
+    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
+        return false;
+    }
+
     psString query = psStringCopy(
         " SELECT DISTINCT"
@@ -2248,4 +2306,19 @@
     psFree(query);
 
+    if (faulted) {
+        // list only faulted rows
+        psStringAppend(&query, " %s", "AND detProcessedImfile.fault != 0");
+    } else {
+        // don't list faulted rows
+        psStringAppend(&query, " %s", "AND detProcessedImfile.fault = 0");
+    }
+
+    // treat limit == 0 as "no limit"
+    if (limit) {
+        psString limitString = psDBGenerateLimitSQL(limit);
+        psStringAppend(&query, " %s", limitString);
+        psFree(limitString);
+    }
+
     psArray *output = p_psDBFetchResult(config->dbh);
     if (!output) {
@@ -2352,8 +2425,14 @@
     }
 
-    // iteration has a default value
+    // default values
     psS32 iteration = psMetadataLookupS32(&status, config->args, "-iteration");
     if (!status) {
         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -iteration");
+        return false;
+    }
+
+    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
         return false;
     }
@@ -2400,5 +2479,6 @@
             bg,
             bg_stdev,
-            bg_mean_stdev
+            bg_mean_stdev,
+            code
         );
 
@@ -2418,4 +2498,17 @@
 {
     PS_ASSERT_PTR_NON_NULL(config, false);
+
+    bool status = false;
+    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
+        return false;
+    }
+
+    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
+        return false;
+    }
 
     // select detStackedImfile.*
@@ -2438,4 +2531,19 @@
         psStringAppend(&query, " AND %s", whereClause);
         psFree(whereClause);
+    }
+
+    if (faulted) {
+        // list only faulted rows
+        psStringAppend(&query, " %s", "AND detStackedImfile.fault != 0");
+    } else {
+        // don't list faulted rows
+        psStringAppend(&query, " %s", "AND detStackedImfile.fault = 0");
+    }
+
+    // treat limit == 0 as "no limit"
+    if (limit) {
+        psString limitString = psDBGenerateLimitSQL(limit);
+        psStringAppend(&query, " %s", limitString);
+        psFree(limitString);
     }
 
@@ -2708,9 +2816,17 @@
     }
 
+    // default values
+    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
+        return false;
+    }
+
     return detNormalizedStatImfileRowAlloc(
         stackedImfile->det_id,
         stackedImfile->iteration,
         stackedImfile->class_id,
-        norm
+        norm,
+        code
     );
 }
@@ -3104,5 +3220,5 @@
     }
 #endif
-
+    
     // treat limit == 0 as "no limit"
     if (limit) {
@@ -3210,4 +3326,11 @@
         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -iteration");        return false;
     }
+
+    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
+        return false;
+    }
+
     // optional
     psString b1_uri = psMetadataLookupStr(&status, config->args, "-b1_uri");
@@ -3290,5 +3413,6 @@
         bg_mean_stdev,
         b1_uri,
-        b2_uri
+        b2_uri,
+        code
     );
 
@@ -3308,4 +3432,17 @@
 {
     PS_ASSERT_PTR_NON_NULL(config, false);
+
+    bool status = false;
+    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
+        return false;
+    }
+
+    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
+        return false;
+    }
 
     psString query = psStringCopy(
@@ -3326,4 +3463,19 @@
     }
 
+    if (faulted) {
+        // list only faulted rows
+        psStringAppend(&query, " %s", "AND detNormalizedExp.fault != 0");
+    } else {
+        // don't list faulted rows
+        psStringAppend(&query, " %s", "AND detNormalizedExp.fault = 0");
+    }
+
+    // treat limit == 0 as "no limit"
+    if (limit) {
+        psString limitString = psDBGenerateLimitSQL(limit);
+        psStringAppend(&query, " %s", limitString);
+        psFree(limitString);
+    }
+
     if (!p_psDBRunQuery(config->dbh, query)) {
         psError(PS_ERR_UNKNOWN, false, "database error");
@@ -3418,4 +3570,11 @@
     if (!status) {
         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -b2_uri");
+        return false;
+    }
+
+    // default values
+    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
         return false;
     }
@@ -3430,5 +3589,6 @@
         bg_mean_stdev,
         b1_uri,
-        b2_uri
+        b2_uri,
+        code
     );
 }
@@ -3581,4 +3741,17 @@
     PS_ASSERT_PTR_NON_NULL(config, false);
 
+    bool status = false;
+    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
+        return false;
+    }
+
+    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
+        return false;
+    }
+
     psString query = psStringCopy(
         "SELECT"
@@ -3602,4 +3775,19 @@
         psStringAppend(&query, " AND %s", whereClause);
         psFree(whereClause);
+    }
+
+    if (faulted) {
+        // list only faulted rows
+        psStringAppend(&query, " %s", "AND detNormalizedImfile.fault != 0");
+    } else {
+        // don't list faulted rows
+        psStringAppend(&query, " %s", "AND detNormalizedImfile.fault = 0");
+    }
+
+    // treat limit == 0 as "no limit"
+    if (limit) {
+        psString limitString = psDBGenerateLimitSQL(limit);
+        psStringAppend(&query, " %s", limitString);
+        psFree(limitString);
     }
 
@@ -3685,5 +3873,6 @@
         "   0.0 as bg_mean_stdev,\n"
         "   'NULL' as b1_uri,\n"
-        "   'NULL' as b2_uri\n"
+        "   'NULL' as b2_uri,\n"
+        "    0 as fault\n"
         " FROM detRun\n"
         " JOIN detInputExp\n"
@@ -3915,4 +4104,11 @@
     }
 
+    // default values
+    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
+        return false;
+    }
+
     // create a new detResidImfileRow and insert it
     return detResidImfileRowAlloc(
@@ -3927,5 +4123,6 @@
             bg_mean_stdev,
             b1_uri,
-            b2_uri
+            b2_uri,
+            code
         );
 }
@@ -3934,4 +4131,17 @@
 {
     PS_ASSERT_PTR_NON_NULL(config, false);
+
+    bool status = false;
+    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
+        return false;
+    }
+
+    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
+        return false;
+    }
 
     // select detResidImfile.*
@@ -3955,4 +4165,19 @@
         psStringAppend(&query, " AND %s", whereClause);
         psFree(whereClause);
+    }
+
+    if (faulted) {
+        // list only faulted rows
+        psStringAppend(&query, " %s", "AND p2ProcessedImfile.fault != 0");
+    } else {
+        // don't list faulted rows
+        psStringAppend(&query, " %s", "AND p2ProcessedImfile.fault = 0");
+    }
+
+    // treat limit == 0 as "no limit"
+    if (limit) {
+        psString limitString = psDBGenerateLimitSQL(limit);
+        psStringAppend(&query, " %s", limitString);
+        psFree(limitString);
     }
 
@@ -4409,4 +4634,10 @@
         return false;
     }
+    // default values
+    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
+        return false;
+    }
 
     // create a new detResidImfileRow and insert it
@@ -4421,5 +4652,6 @@
             b1_uri,
             b2_uri,
-            !reject
+            !reject,
+            code
         );
 }
@@ -4428,4 +4660,17 @@
 {
     PS_ASSERT_PTR_NON_NULL(config, false);
+
+    bool status = false;
+    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
+        return false;
+    }
+
+    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
+        return false;
+    }
 
     psString query = psStringCopy(
@@ -4447,4 +4692,19 @@
         psStringAppend(&query, " AND %s", whereClause);
         psFree(whereClause);
+    }
+
+    if (faulted) {
+        // list only faulted rows
+        psStringAppend(&query, " %s", "AND detResidExp.fault != 0");
+    } else {
+        // don't list faulted rows
+        psStringAppend(&query, " %s", "AND detResidExp.fault = 0");
+    }
+
+    // treat limit == 0 as "no limit"
+    if (limit) {
+        psString limitString = psDBGenerateLimitSQL(limit);
+        psStringAppend(&query, " %s", limitString);
+        psFree(limitString);
     }
 
@@ -4972,4 +5232,10 @@
         return NULL;
     }
+    // default values
+    psS8 code = psMetadataLookupS8(&status, config->args, "-code");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
+        return false;
+    }
 
     return detRunSummaryRowAlloc(
@@ -4979,5 +5245,6 @@
             bg_stdev,
             bg_mean_stdev,
-            accept
+            accept,
+            code
         );
 }
@@ -4986,4 +5253,17 @@
 {
     PS_ASSERT_PTR_NON_NULL(config, false);
+
+    bool status = false;
+    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
+        return false;
+    }
+
+    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -faulted");
+        return false;
+    }
 
     psString query = psStringCopy(
@@ -5003,4 +5283,19 @@
         psStringAppend(&query, " AND %s", whereClause);
         psFree(whereClause);
+    }
+
+    if (faulted) {
+        // list only faulted rows
+        psStringAppend(&query, " %s", "AND p2ProcessedImfile.fault != 0");
+    } else {
+        // don't list faulted rows
+        psStringAppend(&query, " %s", "AND p2ProcessedImfile.fault = 0");
+    }
+
+    // treat limit == 0 as "no limit"
+    if (limit) {
+        psString limitString = psDBGenerateLimitSQL(limit);
+        psStringAppend(&query, " %s", limitString);
+        psFree(limitString);
     }
 
@@ -5564,5 +5859,6 @@
             bg_stdev,
             bg_mean_stdev,
-            true // accept
+            true,   // accept
+            0       // fault code
     )) {
         psError(PS_ERR_UNKNOWN, false, "database error");
@@ -5662,5 +5958,6 @@
             bg_mean_stdev,
             b1_uri,
-            b2_uri
+            b2_uri,
+            0       // fault code
     )) {
         psError(PS_ERR_UNKNOWN, false, "database error");
Index: /trunk/ippTools/src/dettoolConfig.c
===================================================================
--- /trunk/ippTools/src/dettoolConfig.c	(revision 11087)
+++ /trunk/ippTools/src/dettoolConfig.c	(revision 11088)
@@ -231,4 +231,6 @@
     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-b2_uri",  0,
             "define banana 2", NULL);
+    psMetadataAddS8(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
+            "set fault code (required)", 0);
     
     // -processedimfile
@@ -246,4 +248,8 @@
     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-included",  0,
             "restrict results to exposures 'includeded' in the current iteration", false);
+    psMetadataAddU64(processedimfileArgs, PS_LIST_TAIL, "-limit",  0,
+            "limit result set to N items", 0);
+    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,
+            "only return imfiles with a fault status set", false);
     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,
             "use the simple output format", false);
@@ -274,4 +280,6 @@
     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-b2_uri",  0,
             "define banana 2", NULL);
+    psMetadataAddS8(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
+            "set fault code (required)", 0);
 
     // -proccessedexp
@@ -281,4 +289,8 @@
     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-exp_tag",  0,
             "define detrend ID (required)", NULL);
+    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,
+            "limit result set to N items", 0);
+    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,
+            "only return imfiles with a fault status set", false);
     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,
             "use the simple output format", false);
@@ -309,29 +321,6 @@
     psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-uri",  0,
             "define URI (required)", NULL);
-
-    // -tonormalize
-    psMetadata *tonormalizeArgs = psMetadataAlloc();
-    psMetadataAddU64(tonormalizeArgs, PS_LIST_TAIL, "-limit",  0,
-            "limit result set to N items", 0);
-    psMetadataAddBool(tonormalizeArgs, PS_LIST_TAIL, "-simple",  0,
-            "use the simple output format", false);
-
-    // -addnormstat
-    psMetadata *addnormstatArgs = psMetadataAlloc();
-    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-det_id",  0,
-            "define detrend ID (required)", NULL);
-    psMetadataAddS32(addnormstatArgs, PS_LIST_TAIL, "-iteration",  0,
-            "define iteration number", 0);
-    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-class_id",  0,
-            "define class ID", NULL);
-    psMetadataAddF32(addnormstatArgs, PS_LIST_TAIL, "-norm",  0,
-            "define normal value (required)", NAN);
- 
-    // -tonormstat
-    psMetadata *tonormstatArgs = psMetadataAlloc();
-    psMetadataAddU64(tonormstatArgs, PS_LIST_TAIL, "-limit",  0,
-            "limit result set to N items", 0);
-    psMetadataAddBool(tonormstatArgs, PS_LIST_TAIL, "-simple",  0,
-            "use the simple output format", false);
+    psMetadataAddS8(addstackedArgs, PS_LIST_TAIL, "-code",  0,
+            "set fault code (required)", 0);
     
     // -stacked
@@ -345,5 +334,36 @@
     psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-recip",  0,
             "search for recipe", NULL);
+    psMetadataAddU64(stackedArgs, PS_LIST_TAIL, "-limit",  0,
+            "limit result set to N items", 0);
+    psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-faulted",  0,
+            "only return imfiles with a fault status set", false);
     psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-simple",  0,
+            "use the simple output format", false);
+
+    // -tonormalize
+    psMetadata *tonormalizeArgs = psMetadataAlloc();
+    psMetadataAddU64(tonormalizeArgs, PS_LIST_TAIL, "-limit",  0,
+            "limit result set to N items", 0);
+    psMetadataAddBool(tonormalizeArgs, PS_LIST_TAIL, "-simple",  0,
+            "use the simple output format", false);
+
+    // -addnormstat
+    psMetadata *addnormstatArgs = psMetadataAlloc();
+    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-det_id",  0,
+            "define detrend ID (required)", NULL);
+    psMetadataAddS32(addnormstatArgs, PS_LIST_TAIL, "-iteration",  0,
+            "define iteration number", 0);
+    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-class_id",  0,
+            "define class ID", NULL);
+    psMetadataAddF32(addnormstatArgs, PS_LIST_TAIL, "-norm",  0,
+            "define normal value (required)", NAN);
+    psMetadataAddS8(addnormstatArgs, PS_LIST_TAIL, "-code",  0,
+            "set fault code (required)", 0);
+ 
+    // -tonormstat
+    psMetadata *tonormstatArgs = psMetadataAlloc();
+    psMetadataAddU64(tonormstatArgs, PS_LIST_TAIL, "-limit",  0,
+            "limit result set to N items", 0);
+    psMetadataAddBool(tonormstatArgs, PS_LIST_TAIL, "-simple",  0,
             "use the simple output format", false);
 
@@ -368,4 +388,6 @@
     psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-b2_uri", 0,
             "define banana 2", NULL);
+    psMetadataAddS8(addnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,
+            "set fault code (required)", 0);
 
     // -tonormalizedexp
@@ -394,4 +416,6 @@
     psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-b2_uri",  0,
             "define banana 2", NULL);
+    psMetadataAddS8(addnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,
+            "set fault code (required)", 0);
 
     // -normalizedexp
@@ -413,4 +437,8 @@
     psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-b2_uri",  0,
             "define banana 2", NULL);
+    psMetadataAddU64(normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,
+            "limit result set to N items", 0);
+    psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-faulted",  0,
+            "only return imfiles with a fault status set", false);
     psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,
             "use the simple output format", false);
@@ -433,4 +461,8 @@
     psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-recip",  0,
             "search for recipe", NULL);
+    psMetadataAddU64(normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,
+            "limit result set to N items", 0);
+    psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-faulted",  0,
+            "only return imfiles with a fault status set", false);
     psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,
             "use the simple output format", false);
@@ -467,4 +499,6 @@
     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-b2_uri",  0,
             "define banana 2", NULL);
+    psMetadataAddS8(addresidimfileArgs, PS_LIST_TAIL, "-code",  0,
+            "set fault code (required)", 0);
 
     // -residimfile
@@ -480,4 +514,8 @@
     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-recip",  0,
             "search for recipe", NULL);
+    psMetadataAddU64(residimfileArgs, PS_LIST_TAIL, "-limit",  0,
+            "limit result set to N items", 0);
+    psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-faulted",  0,
+            "only return imfiles with a fault status set", false);
     psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-simple",  0,
             "use the simple output format", false);
@@ -503,4 +541,6 @@
     psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-b2_uri",  0,
             "define banana 2", NULL);
+    psMetadataAddS8(addresidexpArgs, PS_LIST_TAIL, "-code",  0,
+            "set fault code (required)", 0);
     psMetadataAddBool(addresidexpArgs, PS_LIST_TAIL, "-reject",  0,
             "exposure is not to be stacked in the next iteration", false);
@@ -516,4 +556,8 @@
     psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-recip",  0,
             "search for recipe", NULL);
+    psMetadataAddU64(residexpArgs, PS_LIST_TAIL, "-limit",  0,
+            "limit result set to N items", 0);
+    psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-faulted",  0,
+            "only return imfiles with a fault status set", false);
     psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-reject",  0,
             "search for acceptable residuals", false);
@@ -563,4 +607,6 @@
     psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
             "define exposue background mean stdev", NAN);
+    psMetadataAddS8(adddetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,
+            "set fault code (required)", 0);
     psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,
             "declare that this detrun iteration is accepted as a master", false);
@@ -572,4 +618,8 @@
     psMetadataAddS32(detrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,
             "search for iteration number", 0);
+    psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-faulted",  0,
+            "only return imfiles with a fault status set", false);
+    psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,
+            "search for acceptable residuals", false);
     psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-simple",  0,
             "use the simple output format", false);