Release retained frozen ICE v2 paper checkpoint and inference metadata

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Deepesh Sonar
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -0,0 +1,16 @@
+ICE — Infinite Context Engine
+Copyright 2026 Deepesh Sonar
+
+This product includes software developed by Deepesh Sonar.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -0,0 +1,132 @@
+---
+license: apache-2.0
+language:
+- en
+base_model: Qwen/Qwen3-Embedding-0.6B
+library_name: pytorch
+tags:
+- conversational-memory
+- lsrep
+- ice-v2
+- reproducibility
+- arxiv:2609.16730
+---
+
+# ICE v2 / LSREP experiment classifier
+
+This releases the retained original classifier checkpoint selected by frozen
+**ICE v2**, the system evaluated in the [LSREP paper](https://arxiv.org/abs/2609.16730).
+It is **not the current ICE v3 classifier**. The `v3` in the historical
+checkpoint filename denotes a classifier training generation, not ICE's system version.
+
+- Repository: [Deepnar/ice](https://github.com/Deepnar/ice).
+- Evaluated source tag: [`v2-paper-eval`](https://github.com/Deepnar/ice/tree/v2-paper-eval).
+- Evaluated commit: `0521df9171b4a7d69f82d12d70497138c77b2678`.
+- Original path: `models/classifier/ice_classifier_v3_qwen_ft3.pt`.
+- Original file size: 212,827 bytes; bare PyTorch state dict.
+- SHA-256: `25c758b6a7e5cf449f3e4c8bb250db759d37cb4f0ab7dd8e0c1acd8afbf05831`.
+
+The checkpoint is copied byte for byte, without retraining or re-export.
+The frozen Git tag records code and the selected path, but does not contain
+checkpoint blobs or a historical checkpoint checksum. This release records the
+checksum of the retained original, rather than claiming a checksum existed at evaluation time.
+
+## Architecture and label order
+
+`Linear(384,128) -> ReLU -> Dropout(0.3) -> Linear(128,25)`;
+52,505 trainable parameters. Call `eval()` to disable dropout.
+The frozen `model.py` is included verbatim. Output coordinates, in order:
+
+```text
+0:11 topics:
+Software_&_Tech, STEM_&_Academics, Business_&_Finance,
+Creative_&_Media, Admin_&_Productivity, Lifestyle_&_Health,
+Social_&_Relationships, World_&_Current_Events, Meta_AI,
+Null_Noise, General_Reference_&_Trivia
+
+11:22 intents:
+Factual_Retrieval, Troubleshooting, Generation, Ideation,
+Analysis_&_Summarization, Strategic_Planning, Decision_Making,
+Emotional_Processing, Utility_Formatting, Casual_Banter, Open_Exploration
+
+22:25 context:
+Zero_Shot, Long_Term_Memory, Real_Time_Search
+```
+
+Topic and intent use sigmoid, a strict `> 0.3` threshold, and an argmax
+fallback when a block has no selected label. Context uses softmax and argmax,
+not independent sigmoids. `max_confidence` is the largest of the 25 decoded
+probabilities. Exact order and settings are also in `config.json`.
+
+## Embeddings and preprocessing
+
+Use frozen `Qwen/Qwen3-Embedding-0.6B`, revision
+`97b0c614be4d77ee51c0cef4e5f07c00f9eb65b3`, with
+`SentenceTransformer(..., device="cpu", truncate_dim=384)`.
+The upstream native width is 1024; ICE v2 takes its first 384 coordinates.
+Use the snapshot's built-in pooling and normalization. Do **not** add
+`normalize_embeddings=True` to `encode()`, renormalize the truncated prefix,
+add a query instruction, or use the current ICE v3 native-width embedding path.
+
+Embed the exact instructional prefix produced by `build_input()` in the included
+`classifier_inference.py`, not the bare user prompt. With context, ICE v2
+selects the last three episodic rows in timestamp order, prefers each summary,
+otherwise uses raw text capped at 150 whitespace words, and caps the combined
+context at 500 words. The frozen `frozen_classifier.py` preserves the exact
+context selection and truncation behavior, including ellipses and the
+context-specific prefix. An empty context uses the no-context prefix.
+
+## Minimal learned-head inference
+
+The frozen tag's dependency versions are `torch==2.11.0`,
+`sentence-transformers==5.5.1`, and `transformers==5.9.0`.
+Use Python 3.11 and `huggingface_hub` to fetch the release:
+
+```python
+import hashlib
+import sys
+from pathlib import Path
+import torch
+from huggingface_hub import snapshot_download
+from sentence_transformers import SentenceTransformer
+
+folder = Path(snapshot_download("Deepnar/ice-v2-classifier"))
+sys.path.insert(0, str(folder))
+from model import ICEClassifier
+from classifier_inference import predict_head
+
+checkpoint = folder / "ice_classifier_v3_qwen_ft3.pt"
+assert hashlib.sha256(checkpoint.read_bytes()).hexdigest() == (
+    "25c758b6a7e5cf449f3e4c8bb250db759d37cb4f0ab7dd8e0c1acd8afbf05831"
+)
+head = ICEClassifier()
+head.load_state_dict(torch.load(checkpoint, map_location="cpu", weights_only=True))
+head.eval()
+embedder = SentenceTransformer(
+    "Qwen/Qwen3-Embedding-0.6B",
+    revision="97b0c614be4d77ee51c0cef4e5f07c00f9eb65b3",
+    device="cpu", truncate_dim=384,
+)
+print(predict_head(head, embedder, "Explain how a database index works."))
+```
+
+For archival reuse, pin `snapshot_download(..., revision=<release commit>)`
+to the upload commit recorded in the GitHub release verification report.
+This is a custom PyTorch head, not a Transformers `AutoModel` or hosted pipeline.
+The example returns **learned-head predictions**. The complete ICE v2 classifier
+also runs the DI3 pre-classifier, hard overrides, and API-level memory policy;
+reproduce those through the frozen Git repository. Neither this helper nor the
+weights alone reproduce full-system routing or the paper's end-to-end scores.
+
+## Limitations and license
+
+No new classifier accuracy claim is made by this release. The paper's fidelity
+audit and negative results remain applicable. Context, preprocessing, rule
+overrides and workload affect behavior. Training data and private conversational
+corpora are not released, so this is checkpoint/inference reproducibility,
+not a claim that private-data training can be independently regenerated.
+
+The ICE head and accompanying ICE code are released under the repository's
+Apache-2.0 license; `LICENSE` and `NOTICE` are included. The separately fetched
+Qwen base model is also Apache-2.0 according to its pinned upstream model card.
+No Qwen base weights, private corpora, caches, secrets, or ICE v3 artifacts are included.

classifier_inference.py

@@ -0,0 +1,47 @@
+"""ICE v2 learned-head input and decoding, without database or DI3 rules."""
+
+import json
+from pathlib import Path
+
+import torch
+
+
+def build_input(prompt: str, context_text: str | None = None) -> str:
+    if context_text:
+        return (
+            f"Conversation context (summarized):\n{context_text}\n\n"
+            "Given the above conversation and the user's latest prompt, predict:\n"
+            "1. TOPIC: what is the subject (Software_&_Tech, Creative_&_Media, etc.)\n"
+            "2. INTENT: what is the user trying to do (Factual_Retrieval, Troubleshooting, etc.)\n"
+            "3. CONTEXT RELIANCE: does the user need memory (Zero_Shot, Long_Term_Memory, Real_Time_Search)\n\n"
+            f"User prompt: {prompt}"
+        )
+    return (
+        "Given a user prompt, predict:\n"
+        "1. TOPIC: what is the subject (Software_&_Tech, Creative_&_Media, etc.)\n"
+        "2. INTENT: what is the user trying to do (Factual_Retrieval, Troubleshooting, etc.)\n"
+        "3. CONTEXT RELIANCE: does the user need memory (Zero_Shot, Long_Term_Memory, Real_Time_Search)\n\n"
+        f"User prompt: {prompt}"
+    )
+
+
+def predict_head(model, embedder, prompt: str, context_text: str | None = None):
+    config = json.loads(Path(__file__).with_name("config.json").read_text())
+    embedding = embedder.encode(build_input(prompt, context_text), convert_to_tensor=True)
+    if embedding.shape != (384,):
+        raise ValueError("ICE v2 requires exactly 384 embedding coordinates")
+    with torch.no_grad():
+        outputs = model(embedding.unsqueeze(0).float())
+        topic = torch.sigmoid(outputs[0, :11])
+        intent = torch.sigmoid(outputs[0, 11:22])
+        context = torch.softmax(outputs[0, 22:], dim=0)
+    def tags(probs, labels):
+        return [labels[i] for i, p in enumerate(probs) if p > 0.3] or [labels[probs.argmax().item()]]
+    probabilities = topic.tolist() + intent.tolist() + context.tolist()
+    return {
+        "topic_tags": tags(topic, config["topic_labels"]),
+        "intent_tags": tags(intent, config["intent_labels"]),
+        "context_reliance": config["context_labels"][context.argmax().item()],
+        "raw_probs": probabilities,
+        "max_confidence": max(probabilities),
+    }

config.json

@@ -0,0 +1,56 @@
+{
+  "system_version": "ICE v2",
+  "source_tag": "v2-paper-eval",
+  "source_commit": "0521df9171b4a7d69f82d12d70497138c77b2678",
+  "checkpoint": "ice_classifier_v3_qwen_ft3.pt",
+  "sha256": "25c758b6a7e5cf449f3e4c8bb250db759d37cb4f0ab7dd8e0c1acd8afbf05831",
+  "base_model": "Qwen/Qwen3-Embedding-0.6B",
+  "base_revision": "97b0c614be4d77ee51c0cef4e5f07c00f9eb65b3",
+  "native_embedding_width": 1024,
+  "embedding_width": 384,
+  "normalize_embeddings": false,
+  "license": "apache-2.0",
+  "architecture": "ICEClassifier",
+  "layers": [
+    384,
+    128,
+    25
+  ],
+  "dropout": 0.3,
+  "topic_labels": [
+    "Software_&_Tech",
+    "STEM_&_Academics",
+    "Business_&_Finance",
+    "Creative_&_Media",
+    "Admin_&_Productivity",
+    "Lifestyle_&_Health",
+    "Social_&_Relationships",
+    "World_&_Current_Events",
+    "Meta_AI",
+    "Null_Noise",
+    "General_Reference_&_Trivia"
+  ],
+  "intent_labels": [
+    "Factual_Retrieval",
+    "Troubleshooting",
+    "Generation",
+    "Ideation",
+    "Analysis_&_Summarization",
+    "Strategic_Planning",
+    "Decision_Making",
+    "Emotional_Processing",
+    "Utility_Formatting",
+    "Casual_Banter",
+    "Open_Exploration"
+  ],
+  "context_labels": [
+    "Zero_Shot",
+    "Long_Term_Memory",
+    "Real_Time_Search"
+  ],
+  "topic_intent_threshold": 0.3,
+  "threshold_comparison": ">",
+  "empty_tag_fallback": "argmax",
+  "context_decode": "softmax then argmax",
+  "scope": "learned head; full classifier also uses DI3, hard overrides and API policy"
+}

frozen_classifier.py

@@ -0,0 +1,202 @@
+import torch
+from sentence_transformers import SentenceTransformer
+from typing import List, Optional
+from .model import ICEClassifier
+from .di3 import run_di3
+from .schemas import ClassificationResult
+from sqlalchemy.orm import Session
+
+
+class PyTorchClassifier:
+    def __init__(self, model_path="models/classifier/ice_classifier.pt",
+                 schema_path="data/labeled/label_schema.json"):
+        # These lists are fixed – the order must match training
+        self.TOPIC_LABELS = [
+            "Software_&_Tech", "STEM_&_Academics", "Business_&_Finance",
+            "Creative_&_Media", "Admin_&_Productivity", "Lifestyle_&_Health",
+            "Social_&_Relationships", "World_&_Current_Events", "Meta_AI",
+            "Null_Noise", "General_Reference_&_Trivia"
+        ]
+        self.INTENT_LABELS = [
+            "Factual_Retrieval", "Troubleshooting", "Generation", "Ideation",
+            "Analysis_&_Summarization", "Strategic_Planning", "Decision_Making",
+            "Emotional_Processing", "Utility_Formatting", "Casual_Banter",
+            "Open_Exploration"
+        ]
+        self.CONTEXT_RELIANCE_LABELS = [
+            "Zero_Shot", "Long_Term_Memory", "Real_Time_Search"
+        ]
+
+        # Load model on CPU
+        self.model = ICEClassifier()
+        self.model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))
+        self.model.eval()
+
+        # Embedder also on CPU
+        # Embedder also on CPU – Qwen3-Embedding truncated to 384 dim for compatibility
+        self.embedder = SentenceTransformer(
+            "Qwen/Qwen3-Embedding-0.6B",
+            device="cpu",
+            truncate_dim=384
+        )
+
+    def _get_context_turns(self, conversation_id: str, n: int = 3, max_total_words: int = 500) -> str:
+        """Return a truncated, summary‑preferring context string from the last *n* turns."""
+        # Local import to avoid circular dependency at module level
+        from src.api.db import SessionLocal
+        db = SessionLocal()
+        try:
+            from src.memory.models import EpisodicMemory
+            turns = (
+                db.query(EpisodicMemory)
+                .filter_by(conversation_id=conversation_id)
+                .order_by(EpisodicMemory.timestamp.desc())
+                .limit(n)
+                .all()
+            )
+            turns.reverse()
+            parts = []
+            total_words = 0
+            for t in turns:
+                # Prefer summary, fall back to raw text (truncated)
+                text = t.summary_text or ""
+                if not text and t.raw_text:
+                    words = t.raw_text.split()
+                    text = " ".join(words[:150]) + "…" if len(words) > 150 else t.raw_text
+                if not text:
+                    continue
+                word_count = len(text.split())
+                if total_words + word_count > max_total_words:
+                    remaining = max_total_words - total_words
+                    if remaining > 20:
+                        w = text.split()
+                        text = " ".join(w[:remaining]) + "…"
+                        parts.append(text)
+                    break
+                parts.append(text)
+                total_words += word_count
+            return "\n".join(parts)
+        finally:
+            db.close()
+
+    # ------------------------------------------------------------------
+    # Main entry point
+    # ------------------------------------------------------------------
+    def classify(
+        self,
+        prompt: str,
+        conversation_history: Optional[List[str]] = None,
+        conversation_length: int = 0,
+        conversation_id: Optional[str] = None,
+    ) -> ClassificationResult:
+        """Public entry point.  Runs DI3 first, falls back to ML.
+        When *conversation_id* is given, the last 3 turns are used as context
+        (auto‑truncated) to improve the ML classifier's accuracy.
+        """
+        if conversation_history is None:
+            conversation_history = []
+        di3_result = run_di3(prompt, conversation_length, conversation_history)
+        if di3_result is not None:
+            # If DI3 forced LTM but left topic/intent blank, let the ML
+            # classifier provide the actual tags while keeping the LTM decision.
+            if not di3_result.topic_tags or not di3_result.intent_tags:
+                ml_result = self._run_ml_classifier(prompt, conversation_id)
+                if di3_result.context_reliance == "Long_Term_Memory":
+                    ml_result.context_reliance = "Long_Term_Memory"
+                return self._apply_hard_overrides(ml_result, prompt)
+            else:
+                return self._apply_hard_overrides(di3_result, prompt)
+
+        return self._run_ml_classifier(prompt, conversation_id)
+
+    def _run_ml_classifier(self, prompt: str, conversation_id: Optional[str] = None) -> ClassificationResult:
+        """Original ML classification path (now private)."""
+        with torch.no_grad():
+            # Build context text if conversation_id is available
+            context_text = None
+            if conversation_id:
+                try:
+                    context_text = self._get_context_turns(conversation_id)
+                except Exception:
+                    context_text = None
+
+            if context_text:
+                prefixed_prompt = (
+                    f"Conversation context (summarized):\n{context_text}\n\n"
+                    f"Given the above conversation and the user's latest prompt, "
+                    f"predict:\n"
+                    f"1. TOPIC: what is the subject (Software_&_Tech, Creative_&_Media, etc.)\n"
+                    f"2. INTENT: what is the user trying to do (Factual_Retrieval, Troubleshooting, etc.)\n"
+                    f"3. CONTEXT RELIANCE: does the user need memory (Zero_Shot, Long_Term_Memory, Real_Time_Search)\n\n"
+                    f"User prompt: {prompt}"
+                )
+            else:
+                prefixed_prompt = (
+                    f"Given a user prompt, predict:\n"
+                    f"1. TOPIC: what is the subject (Software_&_Tech, Creative_&_Media, etc.)\n"
+                    f"2. INTENT: what is the user trying to do (Factual_Retrieval, Troubleshooting, etc.)\n"
+                    f"3. CONTEXT RELIANCE: does the user need memory (Zero_Shot, Long_Term_Memory, Real_Time_Search)\n\n"
+                    f"User prompt: {prompt}"
+                )
+            embedding = self.embedder.encode(prefixed_prompt, convert_to_tensor=True).unsqueeze(0).float()
+            outputs = self.model(embedding)                     # (1, 25)
+
+            topic_out = outputs[:, :11]                         # (1, 11)
+            intent_out = outputs[:, 11:22]                      # (1, 11)
+            ctx_out = outputs[:, 22:]                           # (1, 3)
+
+            topic_probs = torch.sigmoid(topic_out).squeeze(0)   # (11,)
+            intent_probs = torch.sigmoid(intent_out).squeeze(0) # (11,)
+            ctx_probs = torch.softmax(ctx_out, dim=1).squeeze(0) # (3,)
+
+        # Build tag lists
+        topic_tags = [self.TOPIC_LABELS[i] for i in range(len(self.TOPIC_LABELS))
+                      if topic_probs[i] > 0.3]
+        intent_tags = [self.INTENT_LABELS[i] for i in range(len(self.INTENT_LABELS))
+                       if intent_probs[i] > 0.3]
+        if not topic_tags:
+            topic_tags = [self.TOPIC_LABELS[torch.argmax(topic_probs).item()]]
+        if not intent_tags:
+            intent_tags = [self.INTENT_LABELS[torch.argmax(intent_probs).item()]]
+        context_reliance = self.CONTEXT_RELIANCE_LABELS[torch.argmax(ctx_probs).item()]
+
+        # Combine probabilities
+        raw_probs = topic_probs.tolist() + intent_probs.tolist() + ctx_probs.tolist()
+        max_confidence = max(raw_probs)
+
+        result = ClassificationResult(
+            topic_tags=topic_tags,
+            intent_tags=intent_tags,
+            context_reliance=context_reliance,
+            raw_probs=raw_probs,
+            max_confidence=max_confidence,
+            prompt=prompt,
+        )
+        return self._apply_hard_overrides(result, prompt)
+
+    def _apply_hard_overrides(
+        self, result: ClassificationResult, prompt: str
+    ) -> ClassificationResult:
+        """Apply creative/software LTM overrides, but never downgrade an
+        existing Long_Term_Memory decision (e.g. from DI3 or LTM bias)."""
+
+        # If LTM has already been enforced (by DI3 or API‑level bias), keep it
+        if result.context_reliance == "Long_Term_Memory":
+            return result
+
+        if "Creative_&_Media" in result.topic_tags:
+            result.context_reliance = "Long_Term_Memory"
+
+        if "Software_&_Tech" in result.topic_tags:
+            referential_words = [
+                "my", "our", "mine", "ours", "we", "us",
+                "this", "that", "these", "those", "the",
+                "it", "they", "them", "their",
+                "previous", "last", "before", "yesterday", "earlier",
+                "again", "still", "same",
+            ]
+            prompt_lower = prompt.lower()
+            if any(word in prompt_lower for word in referential_words):
+                result.context_reliance = "Long_Term_Memory"
+
+        return result

ice_classifier_v3_qwen_ft3.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25c758b6a7e5cf449f3e4c8bb250db759d37cb4f0ab7dd8e0c1acd8afbf05831
+size 212827

model.py

@@ -0,0 +1,19 @@
+# src/classifier/model.py
+
+import torch
+import torch.nn as nn
+
+class ICEClassifier(nn.Module):
+    def __init__(self):
+        super(ICEClassifier, self).__init__()
+        self.fc1 = nn.Linear(384, 128)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(0.3)
+        self.fc2 = nn.Linear(128, 25)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.relu(x)
+        x = self.dropout(x)
+        x = self.fc2(x)
+        return x