omegon 0.7.7 → 0.8.0

package/extensions/project-memory/factstore.ts

@@ -555,10 +555,13 @@ export class FactStore {
     const source = opts.source ?? "manual";
     const content = opts.content.replace(/^-\s*/, "").trim();
 
-    // Dedup check — same mind, same hash, still active
+    // Dedup check — same mind (or parent chain), same hash, still active.
+    // Check the full chain so directive minds don't duplicate parent facts.
+    const chain = this.resolveMindChain(mind);
+    const dedupPlaceholders = chain.map(() => "?").join(", ");
     const existing = this.db.prepare(
-      `SELECT id FROM facts WHERE mind = ? AND content_hash = ? AND status = 'active'`
-    ).get(mind, hash);
+      `SELECT id FROM facts WHERE mind IN (${dedupPlaceholders}) AND content_hash = ? AND status = 'active'`
+    ).get(...chain, hash);
 
     if (existing) {
       // Reinforce the existing fact instead of duplicating
@@ -646,15 +649,19 @@ export class FactStore {
     let added = 0;
     const newFactIds: string[] = [];
 
+    // Resolve chain once for all observe dedup checks (cached, but avoid repeated map/join)
+    const observeChain = this.resolveMindChain(mind);
+    const observePlaceholders = observeChain.map(() => "?").join(", ");
+
     const tx = this.db.transaction(() => {
       for (const action of actions) {
         switch (action.type) {
           case "observe": {
-            // Fact observed in session — reinforce if exists, add if new
+            // Fact observed in session — reinforce if exists (in mind or parent chain), add if new
             const hash = contentHash(action.content ?? "");
             const existing = this.db.prepare(
-              `SELECT id FROM facts WHERE mind = ? AND content_hash = ? AND status = 'active'`
-            ).get(mind, hash);
+              `SELECT id FROM facts WHERE mind IN (${observePlaceholders}) AND content_hash = ? AND status = 'active'`
+            ).get(...observeChain, hash);
 
             if (existing) {
               this.reinforceFact((existing as { id: string }).id);
@@ -743,7 +750,24 @@ export class FactStore {
    * the minimumConfidence threshold is consistent with the confidence computation.
    */
   sweepDecayedFacts(mind: string): number {
-    const facts = this.getActiveFacts(mind);
+    // Only sweep facts directly in this mind, not inherited from parents.
+    // Parent facts are managed by their own mind's sweep cycle.
+    const facts = this.db.prepare(
+      `SELECT * FROM facts WHERE mind = ? AND status = 'active' ORDER BY section, created_at`
+    ).all(mind) as Fact[];
+    // Apply decay (same logic as getActiveFacts)
+    const NO_DECAY_SECTIONS: readonly string[] = ["Specs"];
+    const now = Date.now();
+    for (const fact of facts) {
+      if (NO_DECAY_SECTIONS.includes(fact.section)) {
+        fact.confidence = 1.0;
+      } else {
+        const lastReinforced = new Date(fact.last_reinforced).getTime();
+        const daysSince = (now - lastReinforced) / (1000 * 60 * 60 * 24);
+        const profile = SECTION_DECAY_OVERRIDES[fact.section] ?? this.decayProfile;
+        fact.confidence = computeConfidence(daysSince, fact.reinforcement_count, profile);
+      }
+    }
     let swept = 0;
 
     for (const fact of facts) {
@@ -848,10 +872,12 @@ export class FactStore {
   getActiveEdges(mind?: string): Edge[] {
     let edges: Edge[];
     if (mind) {
+      const chain = this.resolveMindChain(mind);
+      const placeholders = chain.map(() => "?").join(", ");
       edges = this.db.prepare(`
         SELECT * FROM edges
-        WHERE (source_mind = ? OR target_mind = ?) AND status = 'active'
-      `).all(mind, mind) as Edge[];
+        WHERE (source_mind IN (${placeholders}) OR target_mind IN (${placeholders})) AND status = 'active'
+      `).all(...chain, ...chain) as Edge[];
     } else {
       edges = this.db.prepare(
         `SELECT * FROM edges WHERE status = 'active'`
@@ -947,15 +973,65 @@ export class FactStore {
   // Queries
   // ---------------------------------------------------------------------------
 
+  private mindChainCache = new Map<string, string[]>();
+
+  /**
+   * Resolve the mind chain: [mind, parent, grandparent, ...].
+   * Used to include inherited facts from parent minds.
+   * Stops at 'default' or when no parent exists. Max depth 5 to prevent cycles.
+   * Cached per-mind since the parent chain is immutable within a session.
+   */
+  private resolveMindChain(mind: string): string[] {
+    const cached = this.mindChainCache.get(mind);
+    if (cached) return cached;
+
+    const chain: string[] = [mind];
+    let current = mind;
+    for (let i = 0; i < 5; i++) {
+      const rec = this.getMind(current);
+      if (!rec?.parent || rec.parent === current) break;
+      chain.push(rec.parent);
+      current = rec.parent;
+    }
+    this.mindChainCache.set(mind, chain);
+    return chain;
+  }
+
+  /** Clear the mind chain cache (call after mind creation/deletion). */
+  private invalidateMindChainCache(): void {
+    this.mindChainCache.clear();
+  }
+
   /**
    * Get active facts for a mind, with confidence decay applied.
+   * If the mind has a parent, includes inherited parent facts (deduped
+   * by content_hash — child facts shadow parent facts with the same content).
    * Optionally limit to top N by confidence.
    */
   getActiveFacts(mind: string, limit?: number): Fact[] {
-    const facts = this.db.prepare(
-      `SELECT * FROM facts WHERE mind = ? AND status = 'active'
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
+    const allFacts = this.db.prepare(
+      `SELECT * FROM facts WHERE mind IN (${placeholders}) AND status = 'active'
        ORDER BY section, created_at`
-    ).all(mind) as Fact[];
+    ).all(...chain) as Fact[];
+
+    // Deduplicate: child facts shadow parent facts with the same content_hash.
+    // Keep the fact from the earliest mind in the chain (= the child).
+    const seen = new Map<string, number>();
+    const facts: Fact[] = [];
+    for (const fact of allFacts) {
+      const chainIdx = chain.indexOf(fact.mind);
+      const existing = seen.get(fact.content_hash);
+      if (existing !== undefined && existing <= chainIdx) continue; // child already present
+      seen.set(fact.content_hash, chainIdx);
+      // Remove any previously added parent fact with same hash
+      if (existing !== undefined) {
+        const idx = facts.findIndex(f => f.content_hash === fact.content_hash);
+        if (idx !== -1) facts.splice(idx, 1);
+      }
+      facts.push(fact);
+    }
 
     // Apply time-based confidence decay.
     // Specs are exempt (binary exist/not-exist).
@@ -992,9 +1068,25 @@ export class FactStore {
 
   /** Get active facts for a specific section, sorted by confidence descending. */
   getFactsBySection(mind: string, section: string): Fact[] {
-    const facts = this.db.prepare(
-      `SELECT * FROM facts WHERE mind = ? AND section = ? AND status = 'active' ORDER BY created_at`
-    ).all(mind, section) as Fact[];
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
+    const allFacts = this.db.prepare(
+      `SELECT * FROM facts WHERE mind IN (${placeholders}) AND section = ? AND status = 'active' ORDER BY created_at`
+    ).all(...chain, section) as Fact[];
+    // Deduplicate: child facts shadow parent facts with the same content_hash.
+    const seen = new Map<string, number>();
+    const facts: Fact[] = [];
+    for (const f of allFacts) {
+      const chainIdx = chain.indexOf(f.mind);
+      const existing = seen.get(f.content_hash);
+      if (existing !== undefined && existing <= chainIdx) continue;
+      seen.set(f.content_hash, chainIdx);
+      if (existing !== undefined) {
+        const idx = facts.findIndex(ff => ff.content_hash === f.content_hash);
+        if (idx !== -1) facts.splice(idx, 1);
+      }
+      facts.push(f);
+    }
 
     const NO_DECAY_SECTIONS: readonly string[] = ["Specs"];
     const now = Date.now();
@@ -1015,17 +1107,21 @@ export class FactStore {
 
   /** Get the count of active facts per section for a mind. */
   getSectionCounts(mind: string): Map<string, number> {
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     const rows = this.db.prepare(
-      `SELECT section, COUNT(*) as count FROM facts WHERE mind = ? AND status = 'active' GROUP BY section`
-    ).all(mind) as { section: string; count: number }[];
+      `SELECT section, COUNT(DISTINCT content_hash) as count FROM facts WHERE mind IN (${placeholders}) AND status = 'active' GROUP BY section`
+    ).all(...chain) as { section: string; count: number }[];
     return new Map(rows.map(r => [r.section, r.count]));
   }
 
-  /** Count active facts for a mind */
+  /** Count active facts for a mind (including inherited parent facts) */
   countActiveFacts(mind: string): number {
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     const row = this.db.prepare(
-      `SELECT COUNT(*) as count FROM facts WHERE mind = ? AND status = 'active'`
-    ).get(mind);
+      `SELECT COUNT(DISTINCT content_hash) as count FROM facts WHERE mind IN (${placeholders}) AND status = 'active'`
+    ).get(...chain);
     return row?.count ?? 0;
   }
 
@@ -1036,11 +1132,13 @@ export class FactStore {
     const pattern = `${escaped}%`;
 
     if (mind) {
+      const chain = this.resolveMindChain(mind);
+      const placeholders = chain.map(() => "?").join(", ");
       return this.db.prepare(`
         SELECT * FROM facts
-        WHERE content LIKE ? ESCAPE '\\' AND mind = ? AND status = 'active'
+        WHERE content LIKE ? ESCAPE '\\' AND mind IN (${placeholders}) AND status = 'active'
         ORDER BY created_at DESC
-      `).all(pattern, mind) as Fact[];
+      `).all(pattern, ...chain) as Fact[];
     }
 
     return this.db.prepare(`
@@ -1057,12 +1155,14 @@ export class FactStore {
 
     try {
       if (mind) {
+        const chain = this.resolveMindChain(mind);
+        const placeholders = chain.map(() => "?").join(", ");
         return this.db.prepare(`
           SELECT f.* FROM facts f
           JOIN facts_fts fts ON f.rowid = fts.rowid
-          WHERE facts_fts MATCH ? AND f.mind = ?
+          WHERE facts_fts MATCH ? AND f.mind IN (${placeholders})
           ORDER BY rank
-        `).all(ftsQuery, mind) as Fact[];
+        `).all(ftsQuery, ...chain) as Fact[];
       }
 
       return this.db.prepare(`
@@ -1084,12 +1184,14 @@ export class FactStore {
 
     try {
       if (mind) {
+        const chain = this.resolveMindChain(mind);
+        const placeholders = chain.map(() => "?").join(", ");
         return this.db.prepare(`
           SELECT f.* FROM facts f
           JOIN facts_fts fts ON f.rowid = fts.rowid
-          WHERE facts_fts MATCH ? AND f.mind = ? AND f.status IN ('archived', 'superseded')
+          WHERE facts_fts MATCH ? AND f.mind IN (${placeholders}) AND f.status IN ('archived', 'superseded')
           ORDER BY f.created_at DESC
-        `).all(ftsQuery, mind) as Fact[];
+        `).all(ftsQuery, ...chain) as Fact[];
       }
 
       return this.db.prepare(`
@@ -1326,6 +1428,7 @@ export class FactStore {
       this.db.prepare(`DELETE FROM minds WHERE name = ?`).run(name);
     });
     tx();
+    this.invalidateMindChainCache();
   }
 
   /** Check if a mind exists */
@@ -1339,32 +1442,28 @@ export class FactStore {
     return mind?.readonly === 1;
   }
 
-  /** Fork a mind — copy all active facts to a new mind */
+  /**
+   * Fork a mind — create a child scope that inherits the parent's facts.
+   *
+   * Lightweight: creates the mind record with `parent` set but copies zero
+   * facts, edges, or embeddings. Query methods (getActiveFacts, vector search)
+   * automatically include parent facts via the parent chain. Only facts
+   * explicitly stored in the child are scoped to it.
+   *
+   * On archive, `ingestMind` copies child-only facts back to the parent.
+   */
   forkMind(sourceName: string, newName: string, description: string): void {
-    const tx = this.db.transaction(() => {
-      this.createMind(newName, description, { parent: sourceName });
-
-      const facts = this.getActiveFacts(sourceName);
-      const now = new Date().toISOString();
-
-      for (const fact of facts) {
-        this.db.prepare(`
-          INSERT INTO facts (id, mind, section, content, status, created_at, created_session,
-                             source, content_hash, confidence, last_reinforced,
-                             reinforcement_count, decay_rate)
-          VALUES (?, ?, ?, ?, 'active', ?, NULL, 'ingest', ?, 1.0, ?, ?, ?)
-        `).run(
-          nanoid(), newName, fact.section, fact.content, now,
-          fact.content_hash, now, fact.reinforcement_count, fact.decay_rate,
-        );
-      }
-    });
-    tx();
+    this.createMind(newName, description, { parent: sourceName });
+    this.invalidateMindChainCache();
   }
 
   /** Ingest facts from one mind into another */
   ingestMind(sourceName: string, targetName: string): { factsIngested: number; duplicatesSkipped: number } {
-    const sourceFacts = this.getActiveFacts(sourceName);
+    // Only ingest facts directly stored in the source mind, not inherited from parents.
+    // Inherited facts already exist in the parent (which is typically the target).
+    const sourceFacts = this.db.prepare(
+      `SELECT * FROM facts WHERE mind = ? AND status = 'active' ORDER BY section, created_at`
+    ).all(sourceName) as Fact[];
     let ingested = 0;
     let skipped = 0;
 
@@ -1750,13 +1849,15 @@ export class FactStore {
     return rows.map(r => r.id);
   }
 
-  /** Count facts with vectors for a mind */
+  /** Count facts with vectors for a mind (including parent chain) */
   countFactVectors(mind: string): number {
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     const row = this.db.prepare(`
       SELECT COUNT(*) as count FROM facts_vec v
       JOIN facts f ON v.fact_id = f.id
-      WHERE f.mind = ? AND f.status = 'active'
-    `).get(mind);
+      WHERE f.mind IN (${placeholders}) AND f.status = 'active'
+    `).get(...chain);
     return row?.count ?? 0;
   }
 
@@ -1776,13 +1877,15 @@ export class FactStore {
     const minSim = opts?.minSimilarity ?? 0.3;
     const queryDims = queryVec.length;
 
-    // Get all active facts with vectors for this mind
+    // Get all active facts with vectors for this mind (including parent chain)
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     let query = `
       SELECT f.*, v.embedding, v.dims FROM facts f
       JOIN facts_vec v ON f.id = v.fact_id
-      WHERE f.mind = ? AND f.status = 'active'
+      WHERE f.mind IN (${placeholders}) AND f.status = 'active'
     `;
-    const params: any[] = [mind];
+    const params: any[] = [...chain];
 
     if (opts?.section) {
       query += ` AND f.section = ?`;
@@ -1887,12 +1990,14 @@ export class FactStore {
       const ftsQuery = buildSafeFtsQuery(queryText, "OR");
       if (ftsQuery) {
         try {
+          const ftsChain = this.resolveMindChain(mind);
+          const ftsPlaceholders = ftsChain.map(() => "?").join(", ");
           let query = `
             SELECT f.* FROM facts f
             JOIN facts_fts fts ON f.rowid = fts.rowid
-            WHERE facts_fts MATCH ? AND f.mind = ? AND f.status = 'active'
+            WHERE facts_fts MATCH ? AND f.mind IN (${ftsPlaceholders}) AND f.status = 'active'
           `;
-          const params: any[] = [ftsQuery, mind];
+          const params: any[] = [ftsQuery, ...ftsChain];
           if (opts?.section) {
             query += ` AND f.section = ?`;
             params.push(opts.section);
@@ -1980,12 +2085,14 @@ export class FactStore {
     const queryDims = queryVec.length;
     const contentHashVal = contentHash(factContent);
 
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     const rows = this.db.prepare(`
       SELECT f.*, v.embedding, v.dims FROM facts f
       JOIN facts_vec v ON f.id = v.fact_id
-      WHERE f.mind = ? AND f.section = ? AND f.status = 'active'
+      WHERE f.mind IN (${placeholders}) AND f.section = ? AND f.status = 'active'
         AND f.content_hash != ?
-    `).all(mind, section, contentHashVal) as (Fact & { embedding: Buffer; dims: number })[];
+    `).all(...chain, section, contentHashVal) as (Fact & { embedding: Buffer; dims: number })[];
 
     const results: (Fact & { similarity: number })[] = [];
 
@@ -2071,9 +2178,11 @@ export class FactStore {
 
   /** Get episodes for a mind, ordered by date descending */
   getEpisodes(mind: string, limit?: number): Episode[] {
-    const sql = `SELECT * FROM episodes WHERE mind = ? ORDER BY date DESC` +
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
+    const sql = `SELECT * FROM episodes WHERE mind IN (${placeholders}) ORDER BY date DESC` +
       (limit ? ` LIMIT ${limit}` : "");
-    return this.db.prepare(sql).all(mind) as Episode[];
+    return this.db.prepare(sql).all(...chain) as Episode[];
   }
 
   /** Get a single episode by ID */
@@ -2119,11 +2228,13 @@ export class FactStore {
     const minSim = opts?.minSimilarity ?? 0.3;
     const queryDims = queryVec.length;
 
+    const chain = this.resolveMindChain(mind);
+    const ePlaceholders = chain.map(() => "?").join(", ");
     const rows = this.db.prepare(`
       SELECT e.*, v.embedding, v.dims FROM episodes e
       JOIN episodes_vec v ON e.id = v.episode_id
-      WHERE e.mind = ?
-    `).all(mind) as (Episode & { embedding: Buffer; dims: number })[];
+      WHERE e.mind IN (${ePlaceholders})
+    `).all(...chain) as (Episode & { embedding: Buffer; dims: number })[];
 
     const results: (Episode & { similarity: number })[] = [];
 
@@ -2145,9 +2256,11 @@ export class FactStore {
 
   /** Count episodes for a mind */
   countEpisodes(mind: string): number {
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     const row = this.db.prepare(
-      `SELECT COUNT(*) as count FROM episodes WHERE mind = ?`
-    ).get(mind);
+      `SELECT COUNT(*) as count FROM episodes WHERE mind IN (${placeholders})`
+    ).get(...chain);
     return row?.count ?? 0;
   }
 

package/extensions/project-memory/index.ts

@@ -660,6 +660,33 @@ export default function (pi: ExtensionAPI) {
       // Best effort
     }
 
+    // Drain mind lifecycle queue after store is initialized — fork/activate/ingest/delete
+    // requests from implement/archive flows that were queued before store existed.
+    drainMindLifecycleQueue(ctx);
+
+    // --- Branch↔mind consistency check for directive minds ---
+    // If the active mind is a directive mind (starts with 'directive/'),
+    // verify the current git branch matches the expected branch.
+    // Directive mind "directive/X" expects branch "feature/X".
+    const currentMind = activeMind();
+    if (currentMind.startsWith("directive/")) {
+      const directiveSuffix = currentMind.slice("directive/".length);
+      const expectedBranch = `feature/${directiveSuffix}`;
+      try {
+        const branchResult = await pi.exec("git", ["branch", "--show-current"], { timeout: 3_000, cwd: ctx.cwd });
+        const currentBranch = branchResult.stdout.trim();
+        if (currentBranch && currentBranch !== expectedBranch) {
+          pi.sendMessage({
+            customType: "directive-branch-mismatch",
+            content: `⚠️ Active directive mind "${currentMind}" expects branch "${expectedBranch}" but you are on "${currentBranch}". Run \`git checkout ${expectedBranch}\` to resume directive work.`,
+            display: false,
+          });
+        }
+      } catch {
+        // Git not available or not a git repo — skip check silently
+      }
+    }
+
     triggerState = createTriggerState();
     postCompaction = false;
     firstTurn = true;
@@ -1339,6 +1366,7 @@ export default function (pi: ExtensionAPI) {
   // --- Context Injection ---
 
   pi.on("before_agent_start", async (event, ctx) => {
+    drainMindLifecycleQueue(ctx);
     drainLifecycleCandidateQueue(ctx);
     drainFactArchiveQueue();
     if (!store) return;
@@ -1904,6 +1932,66 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
+  function drainMindLifecycleQueue(ctx: ExtensionContext): void {
+    if (!store) return;
+    const queue = sharedState.mindLifecycleQueue ?? [];
+    if (queue.length === 0) return;
+
+    sharedState.mindLifecycleQueue = [];
+
+    for (const req of queue) {
+      try {
+        switch (req.action) {
+          case "fork": {
+            if (store.mindExists(req.mind)) {
+              // Already forked (e.g. resumed directive) — just skip
+              break;
+            }
+            store.forkMind("default", req.mind, req.description ?? `Directive scope: ${req.mind}`);
+            if (ctx.hasUI) {
+              ctx.ui.notify(`[memory] Forked directive mind '${req.mind}'`, "info");
+            }
+            break;
+          }
+          case "activate": {
+            const target = req.mind === "default" ? null : req.mind;
+            if (target && !store.mindExists(target)) {
+              // Mind doesn't exist (e.g. abandoned before archive) — stay on default
+              break;
+            }
+            store.setActiveMind(target);
+            break;
+          }
+          case "ingest": {
+            const targetMind = req.targetMind ?? "default";
+            if (!store.mindExists(req.mind)) {
+              // Source mind doesn't exist — nothing to ingest
+              break;
+            }
+            const result = store.ingestMind(req.mind, targetMind);
+            if (ctx.hasUI) {
+              ctx.ui.notify(
+                `[memory] Merged '${req.mind}' → '${targetMind}': ${result.factsIngested} ingested, ${result.duplicatesSkipped} deduped`,
+                "info",
+              );
+            }
+            break;
+          }
+          case "delete": {
+            if (req.mind === "default") break; // Safety: never delete default
+            if (!store.mindExists(req.mind)) break;
+            store.deleteMind(req.mind);
+            break;
+          }
+        }
+      } catch (error) {
+        console.error(`[project-memory] Mind lifecycle '${req.action}' failed for '${req.mind}':`, error);
+      }
+    }
+
+    updateStatus(ctx);
+  }
+
   // --- Tools ---
 
   pi.registerTool({
@@ -2908,6 +2996,9 @@ export default function (pi: ExtensionAPI) {
 
     const theme = ctx.ui.theme;
     const mind = activeMind();
+
+    // Publish active mind for dashboard directive indicator
+    sharedState.activeMind = mind === "default" ? null : mind;
     const count = store.countActiveFacts(mind);
 
     // Label + fact count as a single unit: "Memory: 2 facts" or "Memory(mind): 2 facts"

package/node_modules/@babel/runtime/helpers/esm/wrapAsyncGenerator.js

@@ -5,55 +5,42 @@ function _wrapAsyncGenerator(e) {
   };
 }
 function AsyncGenerator(e) {
-  var r, t;
-  function resume(r, t) {
+  var t, n;
+  function resume(t, n) {
     try {
-      var n = e[r](t),
-        o = n.value,
+      var r = e[t](n),
+        o = r.value,
         u = o instanceof OverloadYield;
-      Promise.resolve(u ? o.v : o).then(function (t) {
+      Promise.resolve(u ? o.v : o).then(function (n) {
         if (u) {
-          var i = "return" === r ? "return" : "next";
-          if (!o.k || t.done) return resume(i, t);
-          t = e[i](t).value;
+          var i = "return" === t && o.k ? t : "next";
+          if (!o.k || n.done) return resume(i, n);
+          n = e[i](n).value;
         }
-        settle(n.done ? "return" : "normal", t);
+        settle(!!r.done, n);
       }, function (e) {
         resume("throw", e);
       });
     } catch (e) {
-      settle("throw", e);
+      settle(2, e);
     }
   }
-  function settle(e, n) {
-    switch (e) {
-      case "return":
-        r.resolve({
-          value: n,
-          done: !0
-        });
-        break;
-      case "throw":
-        r.reject(n);
-        break;
-      default:
-        r.resolve({
-          value: n,
-          done: !1
-        });
-    }
-    (r = r.next) ? resume(r.key, r.arg) : t = null;
+  function settle(e, r) {
+    2 === e ? t.reject(r) : t.resolve({
+      value: r,
+      done: e
+    }), (t = t.next) ? resume(t.key, t.arg) : n = null;
   }
-  this._invoke = function (e, n) {
+  this._invoke = function (e, r) {
     return new Promise(function (o, u) {
       var i = {
         key: e,
-        arg: n,
+        arg: r,
         resolve: o,
         reject: u,
         next: null
       };
-      t ? t = t.next = i : (r = t = i, resume(e, n));
+      n ? n = n.next = i : (t = n = i, resume(e, r));
     });
   }, "function" != typeof e["return"] && (this["return"] = void 0);
 }