@aiwg/cli 2026.10.4 → 2026.10.6

package/dist/src/sessions/contracts.js

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import { z } from 'zod';
+import { integer, dateTime, number } from '../schema/zod-validation.mjs';
 import { redactSessionText, redactSessionValue } from './policy.js';
 export const SESSION_CONTRACT_VERSION = '1.0.0';
 export const SESSION_PROVIDER_IDS = [
@@ -20,9 +21,18 @@ export const SessionRuntimeIdentitySchema = z.object({
     canonicalRoot: z.string().nullable(),
     diagnostics: z.array(z.string()),
 });
+export const SessionProviderScopeWarningSchema = z.object({
+    code: z.literal('CONFIGURED_PROVIDERS_OUTSIDE_SCOPE'),
+    configuredProviders: z.array(ExpectedSessionProviderSchema),
+    expectedProviders: z.array(ExpectedSessionProviderSchema),
+    missingProviders: z.array(ExpectedSessionProviderSchema),
+    message: z.string(),
+});
 export const SessionCoveragePreflightSchema = z.object({
     expectedProviders: z.array(ExpectedSessionProviderSchema).min(1),
-    expectedProviderBasis: z.enum(['explicit', 'declared-default', 'legacy']),
+    expectedProviderBasis: z.enum(['explicit', 'workspace-config', 'declared-default', 'legacy']),
+    configuredProviders: z.array(ExpectedSessionProviderSchema).optional(),
+    scopeWarnings: z.array(SessionProviderScopeWarningSchema).optional(),
     supportedProviders: z.array(ExpectedSessionProviderSchema),
     runtime: SessionRuntimeIdentitySchema,
     status: z.enum(['partial', 'complete']),
@@ -37,7 +47,7 @@ export const SessionCoveragePreflightSchema = z.object({
         adapterVersion: z.string().nullable(),
         supportedOperations: z.array(z.string()),
         acquisitionModes: z.array(z.string()),
-        sourceCount: z.number().int().nonnegative(),
+        sourceCount: integer().nonnegative(),
         boundaries: z.array(z.string()),
         remediation: z.string().nullable(),
     })),
@@ -71,7 +81,7 @@ export const SessionErrorCodeSchema = z.enum([
 ]);
 const VersionSchema = z.string().regex(/^\d+\.\d+\.\d+(?:[-+].+)?$/);
 const DigestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
-const NativeExtensionsSchema = z.record(z.unknown()).superRefine((value, context) => {
+const NativeExtensionsSchema = z.record(z.string(), z.unknown()).superRefine((value, context) => {
     for (const key of Object.keys(value)) {
         if (!key.startsWith('native.')) {
             context.addIssue({ code: z.ZodIssueCode.custom, message: `native extension must use native.<provider>: ${key}` });
@@ -90,8 +100,8 @@ export const SessionSourceSchema = z.object({
     disposition: CapabilityDispositionSchema,
     operationalState: OperationalStateSchema,
     consistency: ConsistencyStateSchema,
-    authorizedAt: z.string().datetime({ offset: true }),
-    extensions: NativeExtensionsSchema.default({}),
+    authorizedAt: dateTime({ offset: true }),
+    extensions: NativeExtensionsSchema.prefault({}),
 });
 export const SessionEventSchema = z.object({
     contractVersion: z.literal(SESSION_CONTRACT_VERSION),
@@ -100,7 +110,7 @@ export const SessionEventSchema = z.object({
     sourceId: z.string().min(1),
     importRunId: z.string().min(1),
     nativeId: z.string().min(1).nullable(),
-    sequence: z.number().int().nonnegative(),
+    sequence: integer().nonnegative(),
     kind: z.string().min(1),
     role: z.string().min(1).nullable(),
     participant: z.string().min(1).nullable().default(null),
@@ -109,7 +119,7 @@ export const SessionEventSchema = z.object({
     model: z.string().min(1).nullable().default(null),
     entities: z.array(z.string().min(1)).default([]),
     extractionState: z.string().min(1).nullable().default(null),
-    occurredAt: z.string().datetime({ offset: true }).nullable(),
+    occurredAt: dateTime({ offset: true }).nullable(),
     activityBoundary: z.enum(['pause', 'resume', 'continuation', 'end']).nullable().default(null),
     activityBoundaryBasis: z.string().min(1).nullable().default(null),
     activityBoundaryConfidence: z.enum(['low', 'medium', 'high']).nullable().default(null),
@@ -123,8 +133,8 @@ export const SessionEventSchema = z.object({
     digest: DigestSchema,
     rawReference: z.object({
         locatorClass: z.string().min(1),
-        offset: z.number().int().nonnegative().optional(),
-        sequence: z.number().int().nonnegative().optional(),
+        offset: integer().nonnegative().optional(),
+        sequence: integer().nonnegative().optional(),
     }),
     adapterVersion: VersionSchema,
     consistency: ConsistencyStateSchema,
@@ -133,7 +143,7 @@ export const SessionEventSchema = z.object({
         classes: z.array(z.string().min(1)),
     }),
     opaque: z.boolean().default(false),
-    extensions: NativeExtensionsSchema.default({}),
+    extensions: NativeExtensionsSchema.prefault({}),
 });
 export const SessionSchema = z.object({
     contractVersion: z.literal(SESSION_CONTRACT_VERSION),
@@ -142,8 +152,8 @@ export const SessionSchema = z.object({
     provider: CompatibleSessionProviderIdSchema,
     nativeSessionId: z.string().min(1),
     workspaceId: z.string().min(1),
-    startedAt: z.string().datetime({ offset: true }).nullable(),
-    updatedAt: z.string().datetime({ offset: true }).nullable(),
+    startedAt: dateTime({ offset: true }).nullable(),
+    updatedAt: dateTime({ offset: true }).nullable(),
     consistency: ConsistencyStateSchema,
     lifecycle: z.enum([
         'active', 'inactive', 'paused', 'complete', 'interrupted', 'archived',
@@ -152,10 +162,10 @@ export const SessionSchema = z.object({
     intent: z.object({
         status: z.enum(['selected', 'absent', 'unknown']),
         eventId: z.string().min(1).nullable(),
-        sequence: z.number().int().nonnegative().nullable(),
+        sequence: integer().nonnegative().nullable(),
         title: z.string().nullable(),
         summary: z.string().nullable(),
-    }).default({
+    }).prefault({
         status: 'unknown',
         eventId: null,
         sequence: null,
@@ -163,12 +173,12 @@ export const SessionSchema = z.object({
         summary: null,
     }),
     sourceDigest: DigestSchema,
-    extensions: NativeExtensionsSchema.default({}),
+    extensions: NativeExtensionsSchema.prefault({}),
 });
 export const ImportCheckpointSchema = z.object({
     cursor: z.string(),
-    recordsRead: z.number().int().nonnegative(),
-    bytesRead: z.number().int().nonnegative(),
+    recordsRead: integer().nonnegative(),
+    bytesRead: integer().nonnegative(),
     checkpointVersion: z.literal('2').optional(),
     positionKind: z.enum(['record-index', 'byte-offset', 'provider-native']).optional(),
     sourceGeneration: z.string().min(1).optional(),
@@ -182,8 +192,8 @@ export const ImportCheckpointSchema = z.object({
         'unchanged-replay',
         'unverified',
     ]).optional(),
-    sourceSize: z.number().int().nonnegative().optional(),
-    sourceMtimeMs: z.number().nonnegative().optional(),
+    sourceSize: integer().nonnegative().optional(),
+    sourceMtimeMs: number().check(z.gte(0)).meta({ type: 'number', minimum: 0 }).optional(),
     sourceFileIdentity: z.string().min(1).optional(),
     prefixDigest: DigestSchema.optional(),
 });
@@ -197,8 +207,8 @@ export const ImportRunSchema = z.object({
     consistency: ConsistencyStateSchema,
     status: z.enum(['running', 'committed', 'rolled-back', 'failed']),
     checkpoint: ImportCheckpointSchema,
-    startedAt: z.string().datetime({ offset: true }),
-    completedAt: z.string().datetime({ offset: true }).nullable(),
+    startedAt: dateTime({ offset: true }),
+    completedAt: dateTime({ offset: true }).nullable(),
     errorCode: SessionErrorCodeSchema.nullable(),
 });
 export const ProvenanceEdgeSchema = z.object({
@@ -211,7 +221,7 @@ export const ProvenanceEdgeSchema = z.object({
     fromId: z.string().min(1),
     toId: z.string().min(1),
     importRunId: z.string().min(1),
-    createdAt: z.string().datetime({ offset: true }),
+    createdAt: dateTime({ offset: true }),
 });
 export const IntelligenceCandidateTypeSchema = z.enum([
     'decision', 'requirement', 'constraint', 'preference', 'task', 'discovery',
@@ -222,29 +232,29 @@ export const CandidateSecurityWarningSchema = z.enum([
     'instruction-like', 'structure-breaking', 'control-character', 'bidi-control',
     'unicode-confusable', 'active-content', 'secret-bearing',
 ]);
-export const CandidateSecuritySchema = z.object({
+export const CandidateSecuritySchema = z.strictObject({
     disposition: z.enum(['clear', 'suspicious']),
     warnings: z.array(CandidateSecurityWarningSchema),
     requiresAcknowledgement: z.boolean(),
     acknowledged: z.boolean(),
     policyVersion: VersionSchema,
-}).strict();
-export const IntelligenceCandidateSchema = z.object({
+});
+export const IntelligenceCandidateSchema = z.strictObject({
     contractVersion: z.literal(SESSION_CONTRACT_VERSION),
     candidateId: z.string().min(1),
-    version: z.number().int().positive(),
+    version: integer().positive(),
     type: IntelligenceCandidateTypeSchema,
     assertion: z.string().min(1),
     subject: z.string().min(1).nullable(),
     predicate: z.string().min(1).nullable(),
     object: z.string().min(1).nullable(),
-    evidence: z.array(z.object({
+    evidence: z.array(z.strictObject({
         eventId: z.string().min(1),
-        start: z.number().int().nonnegative(),
-        end: z.number().int().positive(),
+        start: integer().nonnegative(),
+        end: integer().positive(),
         quoteDigest: DigestSchema,
         quote: z.string().min(1).optional(),
-    }).strict()).min(1),
+    })).min(1),
     confidence: z.number().min(0).max(1),
     temporalScope: z.string().min(1),
     projectScope: z.string().min(1),
@@ -253,7 +263,7 @@ export const IntelligenceCandidateSchema = z.object({
     extractionPolicyVersion: VersionSchema,
     model: z.string().min(1).nullable(),
     sensitivity: z.enum(['none', 'sensitive']),
-    security: CandidateSecuritySchema.default({
+    security: CandidateSecuritySchema.prefault({
         disposition: 'clear',
         warnings: [],
         requiresAcknowledgement: false,
@@ -265,8 +275,8 @@ export const IntelligenceCandidateSchema = z.object({
     ]),
     conflictsWith: z.array(z.string().min(1)).default([]),
     supersedes: z.array(z.string().min(1)).default([]),
-    createdAt: z.string().datetime({ offset: true }),
-}).strict().superRefine((candidate, context) => {
+    createdAt: dateTime({ offset: true }),
+}).superRefine((candidate, context) => {
     if (candidate.type === 'relationship'
         && (!candidate.subject || !candidate.predicate || !candidate.object)) {
         context.addIssue({
@@ -275,11 +285,11 @@ export const IntelligenceCandidateSchema = z.object({
         });
     }
 });
-export const CandidateReviewReceiptSchema = z.object({
+export const CandidateReviewReceiptSchema = z.strictObject({
     contractVersion: z.literal(SESSION_CONTRACT_VERSION),
     receiptId: z.string().min(1),
     candidateId: z.string().min(1),
-    candidateVersion: z.number().int().positive(),
+    candidateVersion: integer().positive(),
     fromState: z.enum([
         'pending', 'accepted', 'rejected', 'deferred', 'promoted', 'superseded',
     ]),
@@ -290,18 +300,18 @@ export const CandidateReviewReceiptSchema = z.object({
     reason: z.string().min(1),
     securityWarnings: z.array(CandidateSecurityWarningSchema).default([]),
     securityAcknowledged: z.boolean().default(false),
-    occurredAt: z.string().datetime({ offset: true }),
-}).strict();
-export const PromotionReceiptSchema = z.object({
+    occurredAt: dateTime({ offset: true }),
+});
+export const PromotionReceiptSchema = z.strictObject({
     contractVersion: z.literal(SESSION_CONTRACT_VERSION),
     receiptId: z.string().min(1),
     operationId: z.string().min(1),
     candidateId: z.string().min(1),
-    candidateVersion: z.number().int().positive(),
+    candidateVersion: integer().positive(),
     consumer: z.string().min(1),
     destinationRef: z.string().min(1),
     reviewer: z.string().min(1),
-    approvedAt: z.string().datetime({ offset: true }),
+    approvedAt: dateTime({ offset: true }),
     evidenceEventIds: z.array(z.string().min(1)).min(1),
     conflictsWith: z.array(z.string().min(1)),
     supersedes: z.array(z.string().min(1)),
@@ -309,27 +319,27 @@ export const PromotionReceiptSchema = z.object({
     afterHash: DigestSchema,
     dryRun: z.boolean(),
     duplicate: z.boolean(),
-}).strict();
-export const DeletionReceiptSchema = z.object({
+});
+export const DeletionReceiptSchema = z.strictObject({
     contractVersion: z.literal(SESSION_CONTRACT_VERSION),
     receiptId: z.string().min(1),
     operationId: z.string().min(1),
     scopeClass: z.string().min(1),
-    counts: z.record(z.number().int().nonnegative()),
+    counts: z.record(z.string(), integer().nonnegative()),
     survivingDependentIds: z.array(z.string().min(1)),
     actorClass: z.string().min(1),
     reasonCode: z.string().min(1),
-    orphanCounts: z.record(z.number().int().nonnegative()),
+    orphanCounts: z.record(z.string(), integer().nonnegative()),
     outcome: z.enum(['preview', 'committed', 'failed']),
-    occurredAt: z.string().datetime({ offset: true }),
-}).strict();
-export const PromotionDependencyDecisionSchema = z.object({
+    occurredAt: dateTime({ offset: true }),
+});
+export const PromotionDependencyDecisionSchema = z.strictObject({
     dependentId: z.string().min(1),
     action: z.enum([
         'revoke', 'supersede', 'retain', 'origin_unavailable', 'delete', 'abort',
     ]),
     basis: z.string().min(1),
-}).strict();
+});
 export function assertSessionProviderId(value) {
     const canonical = SESSION_PROVIDER_ALIASES[value] ?? value;
     const parsed = SessionProviderIdSchema.safeParse(canonical);
@@ -364,7 +374,7 @@ function stableId(prefix, ...parts) {
     return `${prefix}_${createHash('sha256').update(parts.join('\0')).digest('hex')}`;
 }
 export const SessionRejectionDetailSchema = z.union([
-    z.object({ limit: z.string(), configured: z.number(), observed: z.number(),
+    z.object({ limit: z.string(), configured: number(), observed: number(),
         setting: z.string().optional(), origin: z.enum(['flag', 'env', 'config', 'default']).optional() }),
     z.object({ issues: z.array(z.object({ path: z.string(), code: z.string() })) }),
 ]);
@@ -381,16 +391,25 @@ export function assertSessionResourceLimit(limit, configured, observed) {
 /** Extract schema locations and validator codes without messages or input values. */
 export function schemaRejectionDetail(error) {
     const issues = [];
-    const visit = (entries) => {
+    const visit = (entries, prefix = []) => {
         for (const issue of entries) {
             if (issues.length >= 20)
                 return;
-            if (issue.code === 'invalid_union') {
-                for (const branch of issue.unionErrors)
-                    visit(branch.issues);
+            const path = [...prefix, ...issue.path];
+            if (issue.code === 'invalid_union' && issue.errors.length === 0) {
+                issues.push({ path: path.join('.') || '<root>', code: 'invalid_union_discriminator' });
+            }
+            else if (issue.code === 'invalid_union') {
+                // Native union branches carry paths relative to their parent union.
+                for (const branch of issue.errors)
+                    visit(branch, path);
             }
             else {
-                issues.push({ path: issue.path.join('.') || '<root>', code: issue.code });
+                // Keep the published diagnostic codes stable across validator versions.
+                const code = issue.code === 'invalid_value'
+                    ? (issue.values.length === 1 ? 'invalid_literal' : 'invalid_enum_value')
+                    : issue.code === 'invalid_format' ? 'invalid_string' : issue.code;
+                issues.push({ path: path.join('.') || '<root>', code });
             }
         }
     };

package/dist/src/sessions/coverage-preflight.js

@@ -19,6 +19,29 @@ export function expectedSessionProviders(values) {
     }
     return [...new Set(providers)].sort();
 }
+export function providerScopeWarnings(configured, expected, recorded = []) {
+    const configuredProviders = configured.length ? expectedSessionProviders(configured) : [];
+    const expectedProviders = expected.length ? expectedSessionProviders(expected) : [];
+    const missingProviders = configuredProviders.filter(provider => !expectedProviders.includes(provider));
+    const current = missingProviders.length ? [{
+            code: 'CONFIGURED_PROVIDERS_OUTSIDE_SCOPE', configuredProviders, expectedProviders, missingProviders,
+            message: `Configured providers outside discovery scope: ${missingProviders.join(', ')}. Rediscover or refresh with current workspace config; verify authorized roots before rebuilding.`,
+        }] : [];
+    return [...recorded, ...current].filter((warning, index, all) => all.findIndex(item => JSON.stringify(item) === JSON.stringify(warning)) === index);
+}
+/** Explicit scope applies once; maintenance combines current config with saved root grants. */
+export function resolveSessionProviderScope(configured, explicit, authorized) {
+    const configuredProviders = configured.length ? expectedSessionProviders(configured) : [];
+    const values = [...configuredProviders, ...(authorized ?? [])];
+    const expectedProviders = expectedSessionProviders(explicit ?? (values.length ? values : SESSION_PROVIDER_IDS));
+    return {
+        expectedProviders,
+        expectedProviderBasis: explicit ? 'explicit' : configuredProviders.length ? 'workspace-config'
+            : authorized?.length ? 'explicit' : 'declared-default',
+        configuredProviders,
+        scopeWarnings: providerScopeWarnings(configuredProviders, expectedProviders),
+    };
+}
 /** Resolve the code actually loaded, independently of cwd, AIWG_ROOT and corpus redirects. */
 export function sessionRuntimeIdentity() {
     const packageRoot = findPackageRoot(dirname(fileURLToPath(import.meta.url)));
@@ -103,6 +126,8 @@ export function coveragePreflight(options = {}) {
     return SessionCoveragePreflightSchema.parse({
         expectedProviders,
         expectedProviderBasis: options.expectedProviderBasis ?? (options.expectedProviders ? 'explicit' : 'declared-default'),
+        ...(options.configuredProviders ? { configuredProviders: options.configuredProviders } : {}),
+        ...(options.scopeWarnings ? { scopeWarnings: options.scopeWarnings } : {}),
         supportedProviders: adapters.map((adapter) => adapter.provider), runtime,
         status: 'partial', unresolvedProviders: expectedProviders, ledger,
     });
@@ -127,7 +152,7 @@ export function reconcileCoveragePreflight(preflight, sources) {
     const runtimeGap = ['mismatch', 'stale', 'unknown'].includes(preflight.runtime.installationState);
     return {
         ...preflight, ledger, unresolvedProviders,
-        status: unresolvedProviders.length > 0 || runtimeGap || preflight.expectedProviderBasis !== 'explicit'
+        status: unresolvedProviders.length > 0 || runtimeGap || !['explicit', 'workspace-config'].includes(preflight.expectedProviderBasis)
             ? 'partial' : 'complete',
     };
 }

package/dist/src/sessions/output-registration.js

@@ -2,34 +2,35 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameS
 import { createHash, randomUUID } from 'node:crypto';
 import { dirname, relative, resolve, sep } from 'node:path';
 import { z } from 'zod';
+import { integer } from '../schema/zod-validation.mjs';
 import { SessionContractError, sha256 } from './contracts.js';
 const DigestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
 const ReferenceSchema = z.string().min(1).max(512).refine(value => !/[\r\n\0]/.test(value), 'references must be single-line inert locators');
-export const OutputSourceReferenceSchema = z.object({
+export const OutputSourceReferenceSchema = z.strictObject({
     kind: z.enum(['file', 'url', 'note', 'session', 'artifact', 'context-pack']),
     ref: ReferenceSchema,
     digest: DigestSchema.nullable().default(null),
-    span: z.object({
-        start: z.number().int().nonnegative(),
-        end: z.number().int().positive(),
+    span: z.strictObject({
+        start: integer().nonnegative(),
+        end: integer().positive(),
         quoteDigest: DigestSchema,
-    }).strict().nullable().default(null),
-}).strict().superRefine((value, context) => {
+    }).nullable().default(null),
+}).superRefine((value, context) => {
     if (value.span && value.span.end <= value.span.start) {
         context.addIssue({ code: z.ZodIssueCode.custom, message: 'source span end must exceed start' });
     }
 });
-export const OutputRegistrationRequestSchema = z.object({
+export const OutputRegistrationRequestSchema = z.strictObject({
     outputPath: z.string().min(1),
     mediaType: z.string().min(1).max(128),
-    contextPack: z.object({
+    contextPack: z.strictObject({
         id: ReferenceSchema,
         digest: DigestSchema,
         sources: z.array(OutputSourceReferenceSchema).min(1).max(256),
-    }).strict(),
+    }),
     supersedes: z.array(ReferenceSchema).max(128).default([]),
     conflictsWith: z.array(ReferenceSchema).max(128).default([]),
-}).strict();
+});
 /**
  * Minimal incremental index sink. Each registration is independently atomic,
  * discoverable, and replay-safe; corpus-wide index builders can consume these

package/dist/src/sessions/policy.js

@@ -56,20 +56,31 @@ async function safeRealpath(path, root = false) {
         throw new SessionContractError('SOURCE_NOT_AUTHORIZED', root ? 'an authorized source root is inaccessible' : 'selected session source is inaccessible');
     }
 }
+// Newline gaps are bounded and each repetition consumes a line break, keeping
+// indentation scans disjoint even on large malformed records (#3273, #3404).
+const VALUE_GAP = /[ \t]*(?:\r?\n[ \t]*){0,2}/.source;
+const NEXT_LINE_GAP = /[ \t]*(?:\r?\n[ \t]*){1,2}/.source;
+const QUOTED_VALUE = /"(?:\\[^\r\n]|[^"\\\r\n])+"|'(?:\\[^\r\n]|[^'\\\r\n])+'|`(?!`)(?:\\[^\r\n]|[^`\\\r\n])+`(?!`)/.source;
+const GENERATED_VALUE = /(?=[A-Za-z0-9._~+/=-]*[0-9])(?=[A-Za-z0-9._~+/=-]*[A-Za-z])[A-Za-z0-9._~+/=-]{20,}/.source;
+function assignmentPattern(key, separator, sameLineValue) {
+    // Only the next-line branch needs stronger evidence: quoted text or a long
+    // generated value. In particular, YAML lists and Markdown fences are prose.
+    return new RegExp(`\\b${key}[ \\t]*${separator}(?:${NEXT_LINE_GAP}(?:${QUOTED_VALUE}|${GENERATED_VALUE})|[ \\t]*(?:${QUOTED_VALUE}|${sameLineValue}))`, 'gi');
+}
 // Ambiguous token components are bounded; whitespace and key blocks use disjoint scans.
 const SECRET_PATTERNS = [
-    ['bearer-token', /\bBearer[ \t]+[A-Za-z0-9._~+/=-]{12,}/gi],
-    ['authorization', /\bAuthorization[ \t]*:[ \t]*[^\r\n]+/gi],
-    ['cookie', /\b(?:Cookie|Set-Cookie)[ \t]*:[ \t]*[^\r\n]+/gi],
-    ['environment-assignment', /\b(?:AWS_SECRET_ACCESS_KEY|[A-Z][A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|PASSWD|API_KEY))[ \t]*=[ \t]*(?:"[^"\r\n]+"|'[^'\r\n]+'|[^\s]+)/gi],
-    ['credential', /\b(?:api[_-]?key|token|password|secret)[ \t]*[:=][ \t]*["']?[^\s"',;]{6,}/gi],
+    ['bearer-token', new RegExp(`\\bBearer(?:[ \\t]+|${NEXT_LINE_GAP})(?:${QUOTED_VALUE}|\\\\"[A-Za-z0-9._~+/=-]{12,}\\\\"|[A-Za-z0-9._~+/=-]{12,})`, 'gi')],
+    ['authorization', new RegExp(`\\bAuthorization[ \\t]*:${VALUE_GAP}[^\\s][^\\r\\n]*`, 'gi')],
+    ['cookie', new RegExp(`\\b(?:Cookie|Set-Cookie)[ \\t]*:${VALUE_GAP}[^\\s][^\\r\\n]*`, 'gi')],
+    ['environment-assignment', assignmentPattern('(?:AWS_SECRET_ACCESS_KEY|[A-Z][A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|PASSWD|API_KEY))', '=', /[^\s]+/.source)],
+    ['credential', assignmentPattern('(?:api[_-]?key|token|password|secret)', '[:=]', /["'`]?[^\s"'`,;]{6,}/.source)],
     ['credential', /^[ \t]*password[ \t]+[^\s]+[ \t]*$/gim],
     // Space-separated values only when they look generated (20+ chars, letters and digits), so prose stays.
-    ['credential', /\b(?:api[_-]?key|token|secret)[ \t]+(?=[A-Za-z0-9._~+/=-]*[0-9])(?=[A-Za-z0-9._~+/=-]*[A-Za-z])[A-Za-z0-9._~+/=-]{20,}/gi],
+    ['credential', new RegExp(`\\b(?:api[_-]?key|token|secret)[ \\t]+${GENERATED_VALUE}`, 'gi')],
     ['provider-token', /\b(?:sk-(?:ant-|proj-)?|[sr]k_(?:live|test)_|gh[pousr]_|github_pat_|glpat-|xai-|npm_|hf_|xox[baprs]-|AKIA|AIza)[A-Za-z0-9._~+/=-]{8,}/g],
     ['provider-token', /https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9_-]+\/[A-Za-z0-9_-]+\/[A-Za-z0-9_-]+/g],
     ['connection-string', /\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis):\/\/[^\s]+/gi],
-    ['credential-url', /\bhttps?:\/\/[^/\s:@]+:[^/\s@]+@[^\s]+/gi],
+    ['credential-url', new RegExp(`\\bhttps?://${VALUE_GAP}[^/\\s:@]+:${VALUE_GAP}(?:${QUOTED_VALUE}|[^/\\s@]+)@${VALUE_GAP}[^\\s"'\x60<>\\\\]+`, 'gi')],
     ['fixture-credential', /\bredaction-canary-[A-Za-z0-9_-]+\b/gi],
     ['email', /\b[A-Z0-9._%+-]{1,64}@[A-Z0-9.-]{1,253}\.[A-Z]{2,63}\b/gi],
 ];

package/dist/src/sessions/refresh.js

@@ -20,7 +20,7 @@ export function sessionRefreshAvailable() {
         return false;
     }
 }
-/** Refresh an existing catalog without inferring or granting provider access. */
+/** Refresh current configured scope within saved provider root grants. */
 export async function refreshSessionCatalog(workspace, full, waitMs, signal, workspaceAliases = [], flags = {}) {
     const canonicalWorkspace = realpathSync(workspace);
     const config = await readAiwgConfig(canonicalWorkspace);
@@ -56,8 +56,7 @@ export async function refreshSessionCatalog(workspace, full, waitMs, signal, wor
             const manifest = await discoverWorkspaceHistories({
                 workspace: canonicalWorkspace,
                 workspaceAliases: [workspace, ...workspaceAliases],
-                expectedProviders: providers,
-                authorizedRoots,
+                refreshFrom: { ...previous, authorizedRoots },
                 registry: createSessionAdapterRegistry(limits),
                 exclude,
                 knownSources: previous.sources,

package/dist/src/sessions/repository.js

@@ -13,7 +13,7 @@ const VISIBLE_SESSION_PREDICATE = `s.lifecycle != 'tombstoned' AND EXISTS (
 )`;
 export class SessionRepository {
     db;
-    constructor(path = ':memory:') {
+    constructor(path = ':memory:', options = {}) {
         let Database;
         try {
             Database = requireFeaturePackage('better-sqlite3');
@@ -23,7 +23,9 @@ export class SessionRepository {
                 'run `aiwg features install sqlite`, then retry. If the native build fails, install ' +
                 'Python 3, make, and a C/C++ compiler supported by node-gyp.', { cause });
         }
-        this.db = new Database(path);
+        this.db = new Database(path, options.readonly ? { readonly: true, fileMustExist: true } : undefined);
+        if (options.readonly)
+            return;
         this.db.pragma('foreign_keys = ON');
         this.db.pragma('journal_mode = WAL');
         this.db.pragma('busy_timeout = 5000');