opencode-swarm 7.107.3 → 7.107.4

package/dist/cli/knowledge-validator-ez3ws8ef.js

@@ -0,0 +1,57 @@
+// @bun
+import {
+  ACTIONABLE_LIST_MAX,
+  ACTIONABLE_STRING_MAX,
+  ALLOWED_SKILL_PATH_PREFIXES,
+  DANGEROUS_COMMAND_ERROR_PATTERNS,
+  DANGEROUS_COMMAND_PATTERNS,
+  DANGEROUS_COMMAND_WARNING_PATTERNS,
+  INJECTION_PATTERNS,
+  INVISIBLE_FORMAT_CHARS,
+  SECURITY_DEGRADING_PATTERNS,
+  _internals,
+  appendUnactionable,
+  auditEntryHealth,
+  quarantineEntry,
+  resolveUnactionablePath,
+  restoreEntry,
+  unarchiveEntry,
+  validateActionability,
+  validateActionableFields,
+  validateLesson,
+  validateSkillCandidatePath,
+  validateSkillPath
+} from "./index-dfdg4ws5.js";
+import"./index-xmarctsf.js";
+import"./index-n1sptn1w.js";
+import"./index-bfwt3abw.js";
+import"./index-9b7qp18e.js";
+import"./index-jtqkh8jf.js";
+import"./index-zgwm4ryv.js";
+import"./index-3naa2ajc.js";
+import"./index-b9v501fr.js";
+import"./index-vn263hqt.js";
+import"./index-a76rekgs.js";
+export {
+  validateSkillPath,
+  validateSkillCandidatePath,
+  validateLesson,
+  validateActionableFields,
+  validateActionability,
+  unarchiveEntry,
+  restoreEntry,
+  resolveUnactionablePath,
+  quarantineEntry,
+  auditEntryHealth,
+  appendUnactionable,
+  _internals,
+  SECURITY_DEGRADING_PATTERNS,
+  INVISIBLE_FORMAT_CHARS,
+  INJECTION_PATTERNS,
+  DANGEROUS_COMMAND_WARNING_PATTERNS,
+  DANGEROUS_COMMAND_PATTERNS,
+  DANGEROUS_COMMAND_ERROR_PATTERNS,
+  ALLOWED_SKILL_PATH_PREFIXES,
+  ACTIONABLE_STRING_MAX,
+  ACTIONABLE_LIST_MAX
+};

package/dist/cli/{pr-subscriptions-0dpn4epk.js → pr-subscriptions-bpvazmsw.js}

@@ -9,14 +9,14 @@ import {
   sweepStale,
   unsubscribe,
   updateSnapshot
-} from "./index-hkpw4wwa.js";
+} from "./index-4r5z8sgw.js";
 import"./index-57ymmh7h.js";
 import"./index-5e4e2hvv.js";
 import"./index-p0arc26j.js";
 import"./index-jtqkh8jf.js";
 import"./index-zgwm4ryv.js";
-import"./index-3naa2ajc.js";
 import"./index-293f68mj.js";
+import"./index-3naa2ajc.js";
 import"./index-b9v501fr.js";
 import"./index-vn263hqt.js";
 import"./index-a76rekgs.js";

package/dist/cli/{schema-vw2ffhe9.js → schema-x0ekqzvs.js}

@@ -85,7 +85,8 @@ import {
   resolveGeneratedAgentRole,
   resolveGuardrailsConfig,
   stripKnownSwarmPrefix
-} from "./index-2560cctg.js";
+} from "./index-pchpahdf.js";
+import"./index-bfwt3abw.js";
 import"./index-p0arc26j.js";
 import"./index-293f68mj.js";
 import"./index-a76rekgs.js";

package/dist/cli/{skill-generator-y6mmq8n5.js → skill-generator-x83re96d.js}

@@ -27,8 +27,12 @@ import {
   retireSkill,
   sanitizeSlug,
   selectCandidateEntries
-} from "./index-9wstcavp.js";
-import"./index-f7nma02k.js";
+} from "./index-bpgqbwmf.js";
+import"./index-dfdg4ws5.js";
+import"./index-kxm3bdjh.js";
+import"./index-xmarctsf.js";
+import"./index-n1sptn1w.js";
+import"./index-bfwt3abw.js";
 import"./index-9b7qp18e.js";
 import"./index-jtqkh8jf.js";
 import"./index-zgwm4ryv.js";

package/dist/commands/knowledge.d.ts

@@ -6,7 +6,11 @@
 export declare function handleKnowledgeQuarantineCommand(directory: string, args: string[]): Promise<string>;
 /**
  * Handles /swarm knowledge restore <id> command.
- * Restores a quarantined knowledge entry.
+ * Restores a quarantined OR archived knowledge entry.
+ *  - If the matched entry is `archived` in `knowledge.jsonl`, calls
+ *    `unarchiveEntry` (G6 #1716) to restore it to its pre-archive status.
+ *  - Otherwise falls through to the quarantine path: reads
+ *    `knowledge-quarantined.jsonl` and calls `restoreEntry`.
  * Accepts a full ID or a unique prefix.
  */
 export declare function handleKnowledgeRestoreCommand(directory: string, args: string[]): Promise<string>;

package/dist/commands/registry.d.ts

@@ -739,9 +739,9 @@ export declare const COMMAND_REGISTRY: {
     };
     readonly 'knowledge restore': {
         readonly handler: (ctx: CommandContext) => Promise<string>;
-        readonly description: "Restore a quarantined knowledge entry <id>";
+        readonly description: "Restore a quarantined or archived knowledge entry <id>";
         readonly subcommandOf: "knowledge";
-        readonly details: "Restores a quarantined knowledge entry back to the active knowledge store by ID. Validates entry ID format (1-64 alphanumeric/hyphen/underscore). Entry must currently be in quarantine state.";
+        readonly details: "Restores a quarantined or archived knowledge entry back to the active knowledge store by ID. Dispatches by current status: an 'archived' entry is restored to its pre-archive status; a 'quarantined' entry is restored from the quarantine sidecar. Validates entry ID format (1-64 alphanumeric/hyphen/underscore).";
         readonly args: "<entry-id>";
         readonly category: "utility";
     };

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

@@ -220,11 +220,11 @@ export declare const RetrospectiveEvidenceSchema: z.ZodObject<{
     user_directives: z.ZodDefault<z.ZodArray<z.ZodObject<{
         directive: z.ZodString;
         category: z.ZodEnum<{
-            tooling: "tooling";
-            code_style: "code_style";
-            architecture: "architecture";
             process: "process";
+            architecture: "architecture";
+            tooling: "tooling";
             other: "other";
+            code_style: "code_style";
         }>;
         scope: z.ZodEnum<{
             global: "global";
@@ -738,11 +738,11 @@ export declare const EvidenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     user_directives: z.ZodDefault<z.ZodArray<z.ZodObject<{
         directive: z.ZodString;
         category: z.ZodEnum<{
-            tooling: "tooling";
-            code_style: "code_style";
-            architecture: "architecture";
             process: "process";
+            architecture: "architecture";
+            tooling: "tooling";
             other: "other";
+            code_style: "code_style";
         }>;
         scope: z.ZodEnum<{
             global: "global";
@@ -1223,11 +1223,11 @@ export declare const EvidenceBundleSchema: z.ZodObject<{
         user_directives: z.ZodDefault<z.ZodArray<z.ZodObject<{
             directive: z.ZodString;
             category: z.ZodEnum<{
-                tooling: "tooling";
-                code_style: "code_style";
-                architecture: "architecture";
                 process: "process";
+                architecture: "architecture";
+                tooling: "tooling";
                 other: "other";
+                code_style: "code_style";
             }>;
             scope: z.ZodEnum<{
                 global: "global";

package/dist/config/schema.d.ts

@@ -328,8 +328,8 @@ export declare const PhaseCompleteConfigSchema: z.ZodObject<{
     }>>>;
     require_docs: z.ZodDefault<z.ZodBoolean>;
     policy: z.ZodDefault<z.ZodEnum<{
-        enforce: "enforce";
         warn: "warn";
+        enforce: "enforce";
     }>>;
     regression_sweep: z.ZodOptional<z.ZodObject<{
         enforce: z.ZodDefault<z.ZodBoolean>;
@@ -600,6 +600,21 @@ export declare const KnowledgeConfigSchema: z.ZodObject<{
     default_max_phases: z.ZodDefault<z.ZodNumber>;
     todo_max_phases: z.ZodDefault<z.ZodNumber>;
     sweep_enabled: z.ZodDefault<z.ZodBoolean>;
+    confidence_floor_action: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        demote: "demote";
+        quarantine: "quarantine";
+    }>>;
+    confidence_floor_min_outcomes: z.ZodDefault<z.ZodNumber>;
+    confidence_floor_signal_threshold: z.ZodDefault<z.ZodNumber>;
+    contradiction_threshold_action: z.ZodDefault<z.ZodEnum<{
+        quarantine: "quarantine";
+        tag_only: "tag_only";
+    }>>;
+    contradiction_quarantine_threshold: z.ZodDefault<z.ZodNumber>;
+    contradiction_quarantine_window_days: z.ZodDefault<z.ZodNumber>;
+    promoted_demotion_min_negative_phases: z.ZodDefault<z.ZodNumber>;
+    promoted_demotion_signal_threshold: z.ZodDefault<z.ZodNumber>;
     realtime_learning_nudge: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         first_after_tool_calls: z.ZodDefault<z.ZodNumber>;
@@ -781,8 +796,8 @@ export type ArchitecturalSupervisionConfig = z.infer<typeof ArchitecturalSupervi
 export declare const KnowledgeApplicationConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     mode: z.ZodDefault<z.ZodEnum<{
-        enforce: "enforce";
         warn: "warn";
+        enforce: "enforce";
     }>>;
     min_confidence: z.ZodDefault<z.ZodNumber>;
     critical_requires_ack: z.ZodDefault<z.ZodBoolean>;
@@ -1284,12 +1299,12 @@ export declare const ExternalSkillCandidateSourceTypeSchema: z.ZodEnum<{
 export type ExternalSkillCandidateSourceType = z.infer<typeof ExternalSkillCandidateSourceTypeSchema>;
 /** Evaluation verdict for an external skill candidate. */
 export declare const ExternalSkillCandidateEvaluationVerdictSchema: z.ZodEnum<{
+    promoted: "promoted";
+    quarantined: "quarantined";
     pending: "pending";
     in_review: "in_review";
-    quarantined: "quarantined";
     passed: "passed";
     rejected: "rejected";
-    promoted: "promoted";
     revoked: "revoked";
 }>;
 export type ExternalSkillCandidateEvaluationVerdict = z.infer<typeof ExternalSkillCandidateEvaluationVerdictSchema>;
@@ -1331,22 +1346,22 @@ export declare const ExternalSkillCandidateSchema: z.ZodObject<{
     skill_body: z.ZodString;
     risk_flags: z.ZodDefault<z.ZodArray<z.ZodString>>;
     evaluation_verdict: z.ZodDefault<z.ZodEnum<{
+        promoted: "promoted";
+        quarantined: "quarantined";
         pending: "pending";
         in_review: "in_review";
-        quarantined: "quarantined";
         passed: "passed";
         rejected: "rejected";
-        promoted: "promoted";
         revoked: "revoked";
     }>>;
     evaluation_history: z.ZodDefault<z.ZodArray<z.ZodObject<{
         verdict: z.ZodEnum<{
+            promoted: "promoted";
+            quarantined: "quarantined";
             pending: "pending";
             in_review: "in_review";
-            quarantined: "quarantined";
             passed: "passed";
             rejected: "rejected";
-            promoted: "promoted";
             revoked: "revoked";
         }>;
         timestamp: z.ZodString;
@@ -1354,12 +1369,12 @@ export declare const ExternalSkillCandidateSchema: z.ZodObject<{
         reason: z.ZodOptional<z.ZodString>;
         candidate_id: z.ZodOptional<z.ZodString>;
         original_verdict: z.ZodOptional<z.ZodEnum<{
+            promoted: "promoted";
+            quarantined: "quarantined";
             pending: "pending";
             in_review: "in_review";
-            quarantined: "quarantined";
             passed: "passed";
             rejected: "rejected";
-            promoted: "promoted";
             revoked: "revoked";
         }>>;
         gate_results: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -1496,8 +1511,8 @@ export declare const PluginConfigSchema: z.ZodObject<{
         }>>>;
         require_docs: z.ZodDefault<z.ZodBoolean>;
         policy: z.ZodDefault<z.ZodEnum<{
-            enforce: "enforce";
             warn: "warn";
+            enforce: "enforce";
         }>>;
         regression_sweep: z.ZodOptional<z.ZodObject<{
             enforce: z.ZodDefault<z.ZodBoolean>;
@@ -1820,6 +1835,21 @@ export declare const PluginConfigSchema: z.ZodObject<{
         default_max_phases: z.ZodDefault<z.ZodNumber>;
         todo_max_phases: z.ZodDefault<z.ZodNumber>;
         sweep_enabled: z.ZodDefault<z.ZodBoolean>;
+        confidence_floor_action: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            demote: "demote";
+            quarantine: "quarantine";
+        }>>;
+        confidence_floor_min_outcomes: z.ZodDefault<z.ZodNumber>;
+        confidence_floor_signal_threshold: z.ZodDefault<z.ZodNumber>;
+        contradiction_threshold_action: z.ZodDefault<z.ZodEnum<{
+            quarantine: "quarantine";
+            tag_only: "tag_only";
+        }>>;
+        contradiction_quarantine_threshold: z.ZodDefault<z.ZodNumber>;
+        contradiction_quarantine_window_days: z.ZodDefault<z.ZodNumber>;
+        promoted_demotion_min_negative_phases: z.ZodDefault<z.ZodNumber>;
+        promoted_demotion_signal_threshold: z.ZodDefault<z.ZodNumber>;
         realtime_learning_nudge: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             first_after_tool_calls: z.ZodDefault<z.ZodNumber>;
@@ -1989,8 +2019,8 @@ export declare const PluginConfigSchema: z.ZodObject<{
     knowledge_application: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         mode: z.ZodDefault<z.ZodEnum<{
-            enforce: "enforce";
             warn: "warn";
+            enforce: "enforce";
         }>>;
         min_confidence: z.ZodDefault<z.ZodNumber>;
         critical_requires_ack: z.ZodDefault<z.ZodBoolean>;

package/dist/hooks/knowledge-curator.d.ts

@@ -95,6 +95,32 @@ export declare function curateAndStoreSwarm(lessons: string[], projectName: stri
  * Auto-promote swarm entries based on phase confirmations and age.
  */
 export declare function runAutoPromotion(directory: string, config: KnowledgeConfig): Promise<void>;
+/**
+ * G7 (#1716): Auto-demote swarm entries that have sustained a net-negative
+ * outcome signal over consecutive phase EVALUATIONS (i.e. consecutive
+ * `runAutoDemotion` invocations with distinct phase numbers — a skipped phase
+ * in between still counts, matching the issue's "≥3 consecutive" intent as
+ * implemented against evaluation cadence, not wall-clock phase contiguity).
+ *
+ * Companion to {@link runAutoPromotion}. For each `promoted` entry:
+ *  1. Dedupe by phase: if `entry.last_demotion_phase === phaseNumber`, this
+ *     entry has already been processed for this phase (handles the case where
+ *     `curateAndStoreSwarm` is invoked multiple times in the same logical
+ *     phase — e.g. phase-complete + close). Skip the counter update.
+ *  2. Otherwise compute the outcome signal. If at/below
+ *     `config.promoted_demotion_signal_threshold`, increment
+ *     `recent_negative_phase_count`; else reset it to 0.
+ *  3. Set `entry.last_demotion_phase = phaseNumber`.
+ *  4. If `recent_negative_phase_count >= config.promoted_demotion_min_negative_phases`,
+ *     demote to `established`: clear `hive_eligible`, clear the G2
+ *     `confidence_floor_demoted` flag (the demotion is the stronger signal),
+ *     and reset the counter.
+ *
+ * Only `promoted` entries are touched. The `phaseInfo.phase_number > 0` gate
+ * at the call site ensures this runs only at phase-complete (not close-time
+ * curation, which hardcodes `phase_number: 0`).
+ */
+export declare function runAutoDemotion(directory: string, config: KnowledgeConfig, phaseNumber: number): Promise<void>;
 /**
  * Create the knowledge curator hook.
  * Watches for writes to .swarm/plan.md and extracts lessons from the retrospective section.
@@ -108,6 +134,7 @@ export declare const _internals: {
     isWriteToEvidenceFile: typeof isWriteToEvidenceFile;
     curateAndStoreSwarm: typeof curateAndStoreSwarm;
     runAutoPromotion: typeof runAutoPromotion;
+    runAutoDemotion: typeof runAutoDemotion;
     createKnowledgeCuratorHook: typeof createKnowledgeCuratorHook;
     seenRetroSections: typeof seenRetroSections;
     recordSeenRetroSection: typeof recordSeenRetroSection;

package/dist/hooks/knowledge-escalator.d.ts

@@ -48,3 +48,19 @@ export declare function readRecentEscalations(directory: string, windowDays?: nu
 export declare function buildEscalationBriefing(escalations: RecentEscalation[], windowDays?: number): string | null;
 /** Run the escalator for several entry IDs (deduped). Never throws. */
 export declare function escalateViolatedEntries(directory: string, entryIds: string[], now?: Date): Promise<EscalationResult[]>;
+export interface ContradictionQuarantineResult {
+    quarantined: boolean;
+    entryId: string;
+    contradictionsInWindow?: number;
+    /** True when the entry was already quarantined/archived (no-op, idempotent). */
+    alreadyInactive?: boolean;
+}
+/**
+ * G3 (#1715): if an entry's `contradicted` count within `windowDays` crosses
+ * `threshold`, auto-quarantine it. Mirrors {@link maybeEscalateOnViolation}
+ * (counts from the RAW event log via {@link countEntryContradictionsInWindow}
+ * — NOT the rollup cache, which is mtime-keyed and can be stale immediately
+ * after an append). Idempotent: already-quarantined/archived entries are
+ * skipped. Never throws.
+ */
+export declare function maybeQuarantineOnContradiction(directory: string, entryId: string, threshold: number, windowDays: number, now?: Date): Promise<ContradictionQuarantineResult>;

package/dist/hooks/knowledge-events.d.ts

@@ -19,6 +19,7 @@
  *   `directory` argument injected by `createSwarmTool` / hook constructors — never
  *   from the process working directory.
  */
+import type { ConfidenceFloorOptions } from './knowledge-store.js';
 import type { KnowledgeApplicationRecord, RetrievalOutcome } from './knowledge-types.js';
 /** Current event-log record schema version. Bump when the on-disk shape changes. */
 export declare const KNOWLEDGE_EVENT_SCHEMA_VERSION = 1;
@@ -285,6 +286,14 @@ export declare function countViolationsInWindow(timestamps: string[], windowDays
  * with more in-window violations). Fail-open: returns 0 on error.
  */
 export declare function countEntryViolationsInWindow(directory: string, entryId: string, windowDays: number, now?: Date): Promise<number>;
+/**
+ * G3 (#1715): count `contradicted` events for an entry within a window, reading
+ * from the RAW event log (NOT the rollup cache — `recomputeCounters` is mtime-
+ * keyed and can be stale immediately after an append, mirroring the
+ * `countEntryViolationsInWindow` discipline above). No legacy-record fold:
+ * contradicted has no legacy counterpart (unlike violated). Fail-open: returns 0.
+ */
+export declare function countEntryContradictionsInWindow(directory: string, entryId: string, windowDays: number, now?: Date): Promise<number>;
 /**
  * Fail-open rollup reader for hot paths. Search and promotion use this instead
  * of stale persisted counters so `knowledge_receipt` feedback affects ranking
@@ -307,6 +316,8 @@ export declare function effectiveRetrievalOutcomes(stored: RetrievalOutcome | un
 export declare function applyKnowledgeVerdictFeedback(directory: string, options?: {
     sinceTimestamp?: string;
     sinceEventId?: string;
+    /** G2: forwarded to bumpKnowledgeConfidenceBatch. */
+    floorOptions?: ConfidenceFloorOptions;
 }): Promise<{
     processed: number;
     bumps: number;

package/dist/hooks/knowledge-reader.d.ts

@@ -2,12 +2,7 @@
  * Merges swarm + hive knowledge, deduplicates (hive wins), ranks by composite score,
  * and provides utility tracking.
  */
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { atomicWriteFile } from '../evidence/task-file.js';
-import { warn } from '../utils/logger.js';
 import { recordKnowledgeEvent } from './knowledge-events.js';
-import { jaccardBigram, normalize, readKnowledge, readRetractionRecords, resolveHiveKnowledgePath, resolveSwarmKnowledgePath, transactFile, wordBigrams } from './knowledge-store.js';
 import type { KnowledgeConfig, KnowledgeEntryBase, KnowledgeRetrievalContext } from './knowledge-types.js';
 export interface ProjectContext {
     projectName: string;
@@ -42,18 +37,6 @@ export declare const _internals: {
     updateRetrievalOutcome: typeof updateRetrievalOutcome;
     scoreDirectiveAgainstContext: typeof scoreDirectiveAgainstContext;
     transactShownFile: typeof transactShownFile;
-    existsSync: typeof existsSync;
-    readFile: typeof readFile;
-    atomicWriteFile: typeof atomicWriteFile;
-    transactFile: typeof transactFile;
-    warn: typeof warn;
-    readKnowledge: typeof readKnowledge;
-    readRetractionRecords: typeof readRetractionRecords;
-    resolveHiveKnowledgePath: typeof resolveHiveKnowledgePath;
-    resolveSwarmKnowledgePath: typeof resolveSwarmKnowledgePath;
-    jaccardBigram: typeof jaccardBigram;
-    normalize: typeof normalize;
-    wordBigrams: typeof wordBigrams;
     recordKnowledgeEvent: typeof recordKnowledgeEvent;
 };
 export {};

package/dist/hooks/knowledge-store.d.ts

@@ -69,7 +69,22 @@ export declare function inferTags(lesson: string): string[];
 export declare function bumpKnowledgeConfidenceBatch(directory: string, deltas: Array<{
     id: string;
     delta: number;
-}>): Promise<void>;
+}>, options?: ConfidenceFloorOptions): Promise<void>;
+/** Options for the G2 confidence-floor action in bumpKnowledgeConfidenceBatch. */
+export interface ConfidenceFloorOptions {
+    /** Action when a just-bumped entry sits at the confidence floor with a
+     * net-negative outcome signal. `'none'` preserves the legacy dead-end
+     * behavior. Default `'demote'`. */
+    floorAction?: 'none' | 'demote' | 'quarantine';
+    /** Minimum total outcome-evidence count required before acting on a
+     * floor entry. Avoids demoting brand-new entries with one stray negative.
+     * Default 3. */
+    floorMinOutcomes?: number;
+    /** Outcome-signal threshold below which a floor entry is acted on
+     * (`computeOutcomeSignal` returns (-1, 1); net-negative is `< 0`).
+     * Default 0. */
+    floorSignalThreshold?: number;
+}
 export declare const _internals: {
     getPlatformConfigDir: typeof getPlatformConfigDir;
     resolveSwarmKnowledgePath: typeof resolveSwarmKnowledgePath;

package/dist/hooks/knowledge-types.d.ts

@@ -126,9 +126,74 @@ export interface KnowledgeEntryBase extends ActionableDirectiveFields {
     auto_generated?: boolean;
     phases_alive?: number;
     max_phases?: number;
+    /** G2 (#1715): set when the confidence-floor action fired (demote).
+     * Suppresses `statusBoost` in retrieval so a floor-clamped entry sinks to
+     * the bottom of ranking without introducing a new retrieval-leaking status.
+     * Cleared if confidence recovers above the floor. */
+    confidence_floor_demoted?: boolean;
+    /** G6 (#1716): recorded at archive time so `unarchiveEntry` can restore the
+     * entry to its prior status. Set by all three archive producers (tool,
+     * curator recommendation, TTL sweep). Absent on entries archived before
+     * this field existed; `unarchiveEntry` falls back to `'candidate'`. */
+    archived_from?: KnowledgeEntryBase['status'];
+    /** G6 (#1716): ISO 8601 timestamp of archival. */
+    archived_at?: string;
+    /** G7 (#1716): consecutive-net-negative-phase counter, incremented by
+     * `runAutoDemotion` when a promoted entry's outcome signal is at/below
+     * `promoted_demotion_signal_threshold`. Reset on a non-negative phase and on
+     * demotion. Used with `last_demotion_phase` to demote at
+     * `promoted_demotion_min_negative_phases` consecutive net-negative phases. */
+    recent_negative_phase_count?: number;
+    /** G7 (#1716): the `phase_number` of the most recent `runAutoDemotion`
+     * counter update. Prevents double-counting when `curateAndStoreSwarm` runs
+     * multiple times in the same logical phase (e.g. phase-complete + close). */
+    last_demotion_phase?: number;
 }
 /** v2 schema marker. v1 entries are still parseable and normalized in-memory by knowledge-store.normalizeEntry. */
 export declare const KNOWLEDGE_SCHEMA_VERSION = 2;
+/**
+ * The single canonical set of inactive (non-retrieval) knowledge statuses.
+ * Every retrieval/filter consumer MUST go through {@link isActiveStatus} rather
+ * than re-deriving its own literal list — the G4 drift (issue #1716) was caused
+ * by exactly that pattern.
+ *
+ * Note: `archived`, `quarantined`, and `quarantined_unactionable` are all
+ * considered inactive. The remaining statuses (`candidate`, `established`,
+ * `promoted`) plus the "unknown" cases (`undefined`/`null`/any future string)
+ * are considered active — the unknown-status case is intentional and preserves
+ * the #828 regression-guard behavior (entries with missing status after
+ * migration are not silently dropped from retrieval).
+ */
+export declare const INACTIVE_STATUSES: ReadonlySet<string>;
+/**
+ * Outcome-signal threshold at or below which a knowledge entry is considered to
+ * have a clearly negative track record (negatives clearly outweigh positives,
+ * with enough corroborating evidence to act on). Tuned against
+ * `computeOutcomeSignal`'s Laplace smoothing so a lone ignore/contradiction
+ * does not trip it.
+ *
+ * G7 (#1716): the canonical home for this value. Previously a module-local
+ * const in `knowledge-curator.ts`; lifted here so the config default
+ * (`promoted_demotion_signal_threshold`) can reference the same value without
+ * a schema→curator import cycle. Both the promotion block and the demotion
+ * threshold share this single source of truth.
+ */
+export declare const OUTCOME_BLOCK_THRESHOLD = -0.3;
+/**
+ * Returns `true` for retrieval-active statuses. Returns `true` for
+ * `undefined`/`null`/unknown strings (preserves the #828 deny-list intent:
+ * entries with unexpected status values are not silently dropped). Returns
+ * `false` only for the three known inactive statuses.
+ *
+ * PRR-009 / design note: issue #1716's G4 section literally requested an
+ * allow-list ("future statuses default to excluded"). We deliberately use a
+ * deny-list here to preserve the #828 regression-guard intent (entries with
+ * missing/unknown status after migration are not silently dropped from
+ * retrieval). The known-inactive leak the issue cares about (the 3 statuses
+ * above) is closed; the hypothetical-future-status robustness is the tradeoff.
+ * Switching to an allow-list would re-introduce #828.
+ */
+export declare function isActiveStatus(status: string | undefined | null): boolean;
 export interface SwarmKnowledgeEntry extends KnowledgeEntryBase {
     tier: 'swarm';
     confirmed_by: PhaseConfirmationRecord[];
@@ -207,6 +272,26 @@ export interface KnowledgeConfig {
     todo_max_phases: number;
     /** Enable age-based sweep of knowledge entries. Default: true */
     sweep_enabled: boolean;
+    /** G2 (#1715): action when an entry sits at the confidence floor with a
+     * net-negative outcome signal. Default: 'demote'. */
+    confidence_floor_action: 'none' | 'demote' | 'quarantine';
+    /** G2: minimum total outcome-evidence count required before acting. Default: 3. */
+    confidence_floor_min_outcomes: number;
+    /** G2: outcome-signal threshold below which a floor entry is acted on. Default: 0. */
+    confidence_floor_signal_threshold: number;
+    /** G3 (#1715): action when contradicted count crosses the threshold. Default: 'quarantine'. */
+    contradiction_threshold_action: 'tag_only' | 'quarantine';
+    /** G3: contradicted-event count in window to trigger the action. Default: 3. */
+    contradiction_quarantine_threshold: number;
+    /** G3: window in days for counting contradicted events. Default: 30. */
+    contradiction_quarantine_window_days: number;
+    /** G7 (#1716): consecutive net-negative phase evaluations required to demote
+     * a `promoted` entry to `established`. Default: 3. */
+    promoted_demotion_min_negative_phases: number;
+    /** G7 (#1716): outcome-signal threshold at or below which a promoted entry's
+     * demotion counter increments for the current phase. Default: -0.3 (matches
+     * `OUTCOME_BLOCK_THRESHOLD`). */
+    promoted_demotion_signal_threshold: number;
     /** Change 5: retrieval-upgrade tuning (MMR / cold-start / synonyms). */
     retrieval?: {
         mmr_lambda?: number;

package/dist/hooks/knowledge-validator.d.ts

@@ -99,11 +99,26 @@ export interface EntryHealthResult {
 export declare function auditEntryHealth(entry: KnowledgeEntryBase): EntryHealthResult;
 export declare function quarantineEntry(directory: string, entryId: string, reason: string, reportedBy: 'architect' | 'user' | 'auto'): Promise<void>;
 export declare function restoreEntry(directory: string, entryId: string): Promise<void>;
+export interface UnarchiveResult {
+    restored: boolean;
+    restored_to?: string;
+    reason?: 'not_found' | 'not_archived' | 'invalid_lesson';
+}
+/**
+ * G6 (#1716): restore an `archived`-status entry from `knowledge.jsonl` to its
+ * pre-archive status (`archived_from` if recorded, else `'candidate'`). Swarm-only
+ * — matches `quarantineEntry`'s scope. Uses the same lock + atomicWrite pattern
+ * as `restoreEntry`. Also resets G7 demotion counters so a restored entry
+ * (especially one restored to `promoted`) is not demoted almost immediately
+ * under the new demotion window.
+ */
+export declare function unarchiveEntry(directory: string, entryId: string): Promise<UnarchiveResult>;
 export declare const _internals: {
     validateLesson: typeof validateLesson;
     auditEntryHealth: typeof auditEntryHealth;
     quarantineEntry: typeof quarantineEntry;
     restoreEntry: typeof restoreEntry;
+    unarchiveEntry: typeof unarchiveEntry;
     extractContextWords: typeof extractContextWords;
     hasSignificantOverlap: typeof hasSignificantOverlap;
 };

package/dist/hooks/skill-usage-log.d.ts

@@ -5,6 +5,7 @@
  * Follows the same append-only JSONL pattern as knowledge-application.jsonl.
  */
 import * as fs from 'node:fs';
+import type { ConfidenceFloorOptions } from './knowledge-store.js';
 /** Single entry in the skill-usage audit log. */
 export interface SkillUsageEntry {
     /** Auto-generated unique identifier (UUID v4). */
@@ -179,6 +180,8 @@ declare function parseGeneratedFromKnowledge(content: string): string[];
  */
 export declare function applySkillUsageFeedback(directory: string, options?: {
     sinceTimestamp?: string;
+    /** G2: forwarded to bumpKnowledgeConfidenceBatch. */
+    floorOptions?: ConfidenceFloorOptions;
 }): Promise<{
     processed: number;
     bumps: number;