Resolve native CLI identifiers across complete saved history

Author: ShadowfetchStudio

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## 0.20.0 — native development (unreleased)
 
+- CLI conversation and job IDs resolve against the full saved history instead
+  of recent-list limits. Old records remain available for continuation, export,
+  rename and job inspection; default conversation selection is project-scoped.
+  Indexed lookup avoids loading unrelated job results just to resolve a prefix.
+
 - Native `tui` frontend shares the Rust engine with desktop and CLI: Unicode
   input, conversation/model/project pickers, task modes, queued follow-ups,
   explicit approvals, tool cards and paged saved history. Terminal-owned workflows

docs/NATIVE_CLI.md

@@ -112,6 +112,12 @@ shadowcode config ui.theme dark
 shadowcode health --test-model
 ```
 
+Conversation and job IDs (including unique prefixes) resolve against the complete
+profile history, independently of recent-list limits. Ambiguous prefixes are
+rejected. Selecting the default conversation searches the current project directly,
+even when other projects have more than 10,000 newer conversations. Job lookup
+reads only the matching record instead of transferring recent jobs and their results.
+
 Exports traverse the full saved history within the service's 32 MB limit.
 File output uses an atomic write; redirected stdout preserves exact export
 bytes. Human display on a terminal strips control characters. With global

docs/NATIVE_VERIFICATION.md

@@ -273,6 +273,19 @@ regression tests verify compact-dialog scrolling/resizing and trust confirmation
 bound to the displayed project; all ten library tests pass after that fix. Broader
 real-terminal resize coverage remains open.
 
+## Full-history identifier resolution
+
+The CLI history regression adds 10,050 newer conversations and 1,100 newer jobs
+with more than 10 MB of unrelated result content to a disposable stopped profile.
+Through a restarted shared engine, full and unique-prefix IDs still retrieve the
+older job, rename/export the older conversation, and choose the correct default
+conversation in a project whose history falls outside the old global list limit.
+Ambiguous prefixes fail. The actual executable passes **16 CLI scenario groups
+with 30 model requests**. The foundation suite passes all 17 tests, including
+indexed ID resolution without deserializing job payloads. Clippy and the native
+executable build pass. General job-list payload sizing and desktop long-history
+display remain separate stress gates.
+
 ## Native CLI
 
 `scripts/test-native-cli.mjs` exercises the actual executable with `DISPLAY` and

native/core/src/cli/mod.rs

@@ -107,26 +107,47 @@ fn unique(rows: &[Value], prefix: &str, label: &str) -> Result<String> {
     );
     Ok(found[0].into())
 }
-async fn sessions(backend: &Backend) -> Result<Vec<Value>> {
-    Ok(backend
-        .call("GET", "/api/sessions?limit=10000", Value::Null)
-        .await?["sessions"]
-        .as_array()
-        .context("Session list missing")?
-        .clone())
+async fn resolve_id(backend: &Backend, kind: &str, prefix: &str) -> Result<String> {
+    let result = backend
+        .call(
+            "GET",
+            query("/api/resolve", &[("kind", kind), ("prefix", prefix)])?,
+            Value::Null,
+        )
+        .await?;
+    Ok(result["id"]
+        .as_str()
+        .context("Resolved identifier missing")?
+        .into())
 }
 async fn session(backend: &Backend, id: Option<&str>, workspace: &Path) -> Result<String> {
-    let rows = sessions(backend).await?;
     if let Some(id) = id {
-        unique(&rows, id, "conversation")
-    } else {
-        rows.iter()
-            .find(|row| row["workspace"].as_str() == workspace.to_str())
-            .and_then(|row| row["id"].as_str())
-            .map(str::to_owned)
-            .context("No conversation in this project; supply --session or run a task first")
+        return resolve_id(backend, "session", id).await;
     }
+    let rows = backend
+        .call(
+            "GET",
+            query(
+                "/api/sessions",
+                &[
+                    (
+                        "workspace",
+                        workspace.to_str().context("Workspace must be UTF-8")?,
+                    ),
+                    ("limit", "1"),
+                ],
+            )?,
+            Value::Null,
+        )
+        .await?;
+    rows["sessions"]
+        .as_array()
+        .and_then(|rows| rows.first())
+        .and_then(|row| row["id"].as_str())
+        .map(str::to_owned)
+        .context("No conversation in this project; supply --session or run a task first")
 }
+
 async fn task(
     backend: &Backend,
     workspace: &Path,
@@ -797,13 +818,7 @@ async fn execute(backend: &Backend, workspace: &Path, options: &Options) -> Resu
             delete,
         } => {
             if rename.is_some() || *delete {
-                let id = unique(
-                    &sessions(backend).await?,
-                    search
-                        .as_deref()
-                        .context("Provide a conversation ID prefix")?,
-                    "conversation",
-                )?;
+                let id = resolve_id(backend,"session",search.as_deref().context("Provide a conversation ID prefix")?).await?;
                 backend
                     .call(
                         if *delete { "DELETE" } else { "PATCH" },
@@ -861,9 +876,8 @@ async fn execute(backend: &Backend, workspace: &Path, options: &Options) -> Resu
             cancel,
             interactive,
         } => {
-            let rows = backend.call("GET", "/api/jobs", Value::Null).await?;
             if let Some(id) = id {
-                let id = unique(rows["jobs"].as_array().context("Jobs missing")?, id, "job")?;
+                let id = resolve_id(backend,"job",id).await?;
                 let job = backend
                     .call(
                         if *cancel { "POST" } else { "GET" },
@@ -891,7 +905,7 @@ async fn execute(backend: &Backend, workspace: &Path, options: &Options) -> Resu
                     !watch_job && !cancel,
                     "Supply a job ID with --watch or --cancel"
                 );
-                rows
+                backend.call("GET", "/api/jobs", Value::Null).await?
             }
         }
         Command::Approvals {

native/core/src/service.rs

@@ -183,6 +183,9 @@ impl Service {
         let text = |key: &str| body[key].as_str().unwrap_or("");
         let q = |key: &str| query.get(key).map(String::as_str).unwrap_or("");
         match (request.method.as_str(), path) {
+            ("GET", "/api/resolve") => {
+                return Ok(json!({"id":store.resolve_id(q("kind"),q("prefix"))?}))
+            }
             #[cfg(unix)]
             ("GET", "/api/plugins") => {
                 return crate::plugins::catalog(

native/core/src/store.rs

@@ -224,6 +224,36 @@ impl Store {
             .into_iter()
             .next())
     }
+    /// Resolve identifiers against the complete indexed history, never a recent
+    /// list of potentially large job payloads. Two rows suffice for ambiguity.
+    pub fn resolve_id(&self, kind: &str, prefix: &str) -> Result<String> {
+        ensure!(
+            !prefix.is_empty()
+                && prefix.len() <= 128
+                && prefix
+                    .bytes()
+                    .all(|b| b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_')),
+            "Provide a valid ID or ID prefix"
+        );
+        let table = match kind {
+            "session" => "sessions",
+            "job" => "desktop_jobs",
+            _ => anyhow::bail!("Unknown identifier kind"),
+        };
+        let rows = self.query(
+            &format!("SELECT id FROM {table} WHERE id>=? AND id<? ORDER BY id LIMIT 2"),
+            params![prefix, format!("{prefix}~")],
+        )?;
+        ensure!(!rows.is_empty(), "No {kind} matches {prefix}");
+        ensure!(
+            rows.len() == 1,
+            "Choose a unique {kind} ID prefix; at least two matches found"
+        );
+        Ok(rows[0]["id"]
+            .as_str()
+            .context("Stored identifier missing")?
+            .into())
+    }
     pub fn sessions(&self, search: &str, limit: usize) -> Result<Vec<Value>> {
         self.sessions_in(search, limit, None)
     }

native/core/tests/foundations.rs

@@ -518,3 +518,48 @@ fn search_respects_ignored_files_and_result_limits() {
         .iter()
         .all(|v| v["path"] == "src/test.rs"));
 }
+
+#[test]
+fn identifier_resolution_uses_all_history_and_rejects_ambiguous_or_invalid_prefixes() {
+    let root = tempfile::tempdir().unwrap();
+    let path = root.path().join("history.db");
+    let store = Store::open(&path).unwrap();
+    let mut db = rusqlite::Connection::open(&path).unwrap();
+    let tx = db.transaction().unwrap();
+    tx.execute("INSERT INTO sessions(id,workspace,created_at,updated_at,status,title) VALUES('old-session','/old',1,1,'idle','Older conversation')",[]).unwrap();
+    tx.execute(
+        "INSERT INTO desktop_jobs(id,payload) VALUES('old-job','not decoded by ID lookup')",
+        [],
+    )
+    .unwrap();
+    tx.execute("WITH RECURSIVE n(i) AS (VALUES(1) UNION ALL SELECT i+1 FROM n WHERE i<10050) INSERT INTO sessions(id,workspace,created_at,updated_at,status,title) SELECT printf('new-%05d',i),'/new',i+1,i+1,'idle','Newer conversation' FROM n",[]).unwrap();
+    tx.execute("WITH RECURSIVE n(i) AS (VALUES(1) UNION ALL SELECT i+1 FROM n WHERE i<1100) INSERT INTO desktop_jobs(id,payload) SELECT printf('new-job-%05d',i),'not decoded by ID lookup' FROM n",[]).unwrap();
+    tx.commit().unwrap();
+    assert_eq!(store.resolve_id("session", "old-").unwrap(), "old-session");
+    assert_eq!(store.resolve_id("job", "old-job").unwrap(), "old-job");
+    assert!(store
+        .resolve_id("session", "new-")
+        .unwrap_err()
+        .to_string()
+        .contains("unique"));
+    assert!(store
+        .resolve_id("job", "new-job-")
+        .unwrap_err()
+        .to_string()
+        .contains("unique"));
+    assert!(store
+        .resolve_id("job", "missing")
+        .unwrap_err()
+        .to_string()
+        .contains("No job"));
+    for bad in ["", "%", "_ OR 1=1", "../job", "a/b"] {
+        assert!(store.resolve_id("job", bad).is_err());
+    }
+    assert!(store.resolve_id("events", "old-job").is_err());
+    assert_eq!(
+        store
+            .sessions_in("", 1, Some(std::path::Path::new("/old")))
+            .unwrap()[0]["id"],
+        "old-session"
+    );
+}

scripts/test-native-cli.mjs

@@ -373,6 +373,25 @@ try {
   assert.ok((await cli(["background", "list"])).tasks.every(t => !["RUNNING", "STARTING", "STOPPING"].includes(t.status)));
   assert.equal(await readFile(path.join(project, "unexpected")).then(() => true, () => false), false);
   checks.push("remote command disconnect and persistent-owner shutdown clean process groups and release the profile");
+  // Seed only this disposable, stopped profile. Recent-list limits must not hide
+  // older IDs or force fetching multi-megabyte job results to resolve a prefix.
+  const historyDb = new DatabaseSync(path.join(profile, "state/shadow-agent.db"));
+  const oldProject=path.join(scratch,"old-project"); await mkdir(oldProject);
+  historyDb.exec("BEGIN");
+  historyDb.prepare("INSERT INTO sessions(id,workspace,created_at,updated_at,status,title) VALUES(?,?,1,1,'idle','Old project history')").run("old-project-session",oldProject);
+  historyDb.exec("WITH RECURSIVE n(i) AS (VALUES(1) UNION ALL SELECT i+1 FROM n WHERE i<10050) INSERT INTO sessions(id,workspace,created_at,updated_at,status,title) SELECT printf('noise-session-%05d',i),'/noise',9999999999,9999999999,'idle','Newer fixture' FROM n");
+  const putHistoryJob=historyDb.prepare("INSERT INTO desktop_jobs(id,payload) VALUES(?,?)");
+  for(let i=0;i<1100;i++){const id=`noise-job-${i.toString().padStart(5,'0')}`;putHistoryJob.run(id,JSON.stringify({id,workspace:project,session_id:task.session_id,task_id:task.task_id,status:"completed",result:{summary:"x".repeat(9000)}}));}
+  historyDb.exec("COMMIT");historyDb.close();
+  server=launch(["--json","serve"]);await until("History owner",()=>server.output.stderr.includes("serving"));
+  assert.equal((await cli(["jobs",task.id])).id,task.id);
+  assert.equal((await cli(["jobs",task.id.slice(0,12)])).id,task.id);
+  await cli(["sessions",task.session_id.slice(0,12),"--rename","Old history remains reachable"]);
+  assert.equal((await cli(["export","--session",task.session_id.slice(0,12)])).content.includes("CLI completed"),true);
+  assert.ok((await cli(["export"],0,{workspace:oldProject})).content.includes("Old project history"));
+  assert.match((await cli(["jobs","noise-job"],1)).error,/unique/);
+  await interrupt(server,"SIGTERM");await finish(server);
+  checks.push("indexed full-history IDs and project-default selection beyond 10,000 sessions and 1,000 large jobs");
   await writeFile(path.join(artifacts, "result.json"), JSON.stringify({ passed: true, binary, modelRequests: requests, checks }, null, 2));
   console.log(`Native CLI passed ${checks.length} scenario groups with ${requests} model requests.`);
 } catch (error) {