@@ -334,7 +334,15 @@ private void renderInstallProgress(org.iiab.controller.install.presentation.Inst
             case DOWNLOADING:
                 btnFastInstall.setText(getString(R.string.install_status_os_download, s.percent, s.speed));
                 break;
-            case EXTRACTING:
+            case EXTRACTING: {
+                // ADFA-4915: legacy button shows the extract % (or "…" during the reading sub-phase).
+                String lbl = org.iiab.controller.deploy.domain.ExtractProgress.firstLine(
+                        getString(R.string.install_status_extracting));
+                btnFastInstall.setText(s.percent < 0
+                        ? (getString(R.string.k2go_reading) + "  …")
+                        : (lbl + "  " + s.percent + "%"));
+                break;
+            }
             case PROVISIONING:
                 btnFastInstall.setText(s.message);
                 break;
 
@@ -10,6 +10,7 @@
 package org.iiab.controller;
 
 import org.iiab.controller.deploy.domain.ArchiveEntry;
+import org.iiab.controller.deploy.domain.ExtractProgress;
 
 import android.content.Context;
 import android.os.Handler;
@@ -37,6 +38,14 @@ public interface ExtractionListener {
 
         /** A streamed line of extraction output (verbose tar). Default no-op. */
         default void onProgress(String line) { }
+
+        /**
+         * ADFA-4915: determinate extraction progress. {@code percent} is clamped to
+         * [0,99] while extracting and set to 100 exactly once on completion; {@code done}
+         * / {@code total} are archive-member counts; {@code line} is the current verbose
+         * tar line (may be empty). Default no-op.
+         */
+        default void onProgress(int percent, long done, long total, String line) { }
     }
 
     public void startExtraction(Context context, String archivePath, String destDir, ExtractionListener listener) {
@@ -79,6 +88,11 @@ public void startExtraction(Context context, String archivePath, String destDir,
                     }
                 }
 
+                // ADFA-4915: entries.size() is the extraction denominator (members), already
+                // computed above for the traversal/ABI checks — no extra tar pass.
+                final long totalMembers = entries.size();
+                final long[] doneMembers = {0L};
+
                 // For untrusted imports/restores: it must be a valid rootfs of THIS
                 // app's architecture (ABI policy: 32<->32, 64<->64). Reuses the
                 // listing above. Fail closed before extracting.
@@ -134,10 +148,16 @@ public void startExtraction(Context context, String archivePath, String destDir,
                                 lastLog[0] = now;
                                 Log.d(TAG, "Tar Output: " + line);
                             }
+                            doneMembers[0]++;   // ADFA-4915: ~one verbose line per member (stray stderr lines just push toward the 99% clamp)
                             if (now - lastEmit[0] >= 50) {
                                 lastEmit[0] = now;
                                 final String l = line;
-                                uiHandler.post(() -> listener.onProgress(l));
+                                final long d = doneMembers[0];
+                                final int pct = ExtractProgress.percent(d, totalMembers);
+                                uiHandler.post(() -> {
+                                    listener.onProgress(l);
+                                    listener.onProgress(pct, d, totalMembers, l);
+                                });
                             }
                         }
                     } catch (Exception ignored) {
@@ -201,6 +221,7 @@ public void startExtraction(Context context, String archivePath, String destDir,
                 new Handler(Looper.getMainLooper()).post(() -> {
                     if (exitCode == 0 && !broke) {
                         Log.d(TAG, "Extraction successful.");
+                        listener.onProgress(100, totalMembers, totalMembers, "");   // ADFA-4915: 100% only on completion
                         listener.onComplete(destDir);
                     } else {
                         String diag = "tar exit=" + exitCode
 
@@ -0,0 +1,51 @@
+/*
+ * ============================================================================
+ * Name        : ExtractProgress.java
+ * Author      : AppDevForAll
+ * Copyright   : Copyright (c) 2026 AppDevForAll
+ * Description : ADFA-4915. Pure rules for the rootfs Extract phase UI:
+ *               - percent(done,total): members_extracted / total, clamped [0,99]
+ *                 (100 is reserved for completion, set explicitly by the caller).
+ *               - firstLine(text): the first line of a multi-line label.
+ *               - fileLabel(line): basename of a verbose tar line (files only;
+ *                 "" for directory entries or empty input).
+ *               Pure JVM (no android.*) => unit-testable.
+ * ============================================================================
+ */
+package org.iiab.controller.deploy.domain;
+
+public final class ExtractProgress {
+
+    private ExtractProgress() { }
+
+    /**
+     * Percent of archive members extracted so far, clamped to [0,99].
+     * Returns 0 when nothing is known yet (total unknown/empty or done<=0).
+     * 99 is the cap during extraction; the caller sets 100 only on completion.
+     */
+    public static int percent(long done, long total) {
+        if (total <= 0L || done <= 0L) return 0;
+        long p = done * 100L / total;
+        if (p < 0L) return 0;
+        if (p > 99L) return 99;
+        return (int) p;
+    }
+
+    /** First line of a possibly multi-line label, trimmed. Null-safe. */
+    public static String firstLine(String s) {
+        if (s == null) return "";
+        int i = s.indexOf('\n');
+        return (i >= 0 ? s.substring(0, i) : s).trim();
+    }
+
+    /**
+     * Basename of a verbose tar line: the segment after the last '/'.
+     * Returns "" for empty input or a directory entry (line ends with '/'),
+     * so the UI shows only files, never a bare directory path.
+     */
+    public static String fileLabel(String line) {
+        if (line == null || line.isEmpty() || line.endsWith("/")) return "";
+        int slash = line.lastIndexOf('/');
+        return slash >= 0 ? line.substring(slash + 1) : line;
+    }
+}
@@ -60,6 +60,7 @@ public boolean isRunning() {
     // All posts are thread-safe (callable from the aria2 / proot worker threads).
     public void postDownloading(int percent, String speed) { post(InstallState.downloading(percent, speed)); }
     public void postExtracting(String message)             { post(InstallState.extracting(message)); }
+    public void postExtracting(int percent, String message) { post(InstallState.extracting(percent, message)); }
     public void postProvisioning(String message)           { post(InstallState.provisioning(message)); }
     public void postSuccess()                               { post(InstallState.success()); }
     public void postFailed(String message)                  { post(InstallState.failed(message)); }
 
@@ -301,7 +301,7 @@ public void onIntegrityFailure(String reason) {
     }
 
     private void onRootfsDownloaded(String downloadPath) {
-        InstallProgressRepository.get().postExtracting(getString(R.string.install_status_extracting));
+        InstallProgressRepository.get().postExtracting(-1, "");   // ADFA-4915: -1 = indeterminate "reading/listing" until the first member is extracted
         updateNotification(getString(R.string.install_status_extracting));
 
         File downloadDir = new File(downloadPath);
@@ -315,6 +315,11 @@ private void onRootfsDownloaded(String downloadPath) {
         File downloadedArchive = archives[0];
         new TarExtractor().startExtraction(this, downloadedArchive.getAbsolutePath(), iiabRootDir.getAbsolutePath(),
                 new TarExtractor.ExtractionListener() {
+                    @Override
+                    public void onProgress(int percent, long done, long total, String line) {
+                        InstallProgressRepository.get().postExtracting(percent, line);
+                    }
+
                     @Override
                     public void onComplete(String destDir) {
                         if (cancelled) return;
 
@@ -22,9 +22,11 @@ public enum Op { INSTALL, RESET }
 
     public final Phase phase;
     public final Op op;
-    public final int percent;     // 0..100, meaningful for DOWNLOADING
+    // 0..100 for DOWNLOADING and for EXTRACTING while extracting; -1 means
+    // indeterminate (the EXTRACTING "reading/listing" sub-phase, ADFA-4915).
+    public final int percent;
     public final String speed;    // e.g. "12.3MiB", may be empty
-    public final String message;  // resolved status text / error to render
+    public final String message;  // resolved status text / current file line / error
     public final long seq;        // assigned by the repository; identifies terminal events
 
     private InstallState(Phase phase, Op op, int percent, String speed, String message, long seq) {
@@ -66,6 +68,15 @@ public static InstallState extracting(String message) {
         return new InstallState(Phase.EXTRACTING, Op.INSTALL, 0, "", message, 0L);
     }
 
+    /**
+     * ADFA-4915: determinate extract progress. {@code percent} is pre-clamped by
+     * ExtractProgress (0..99, then 100 on completion) or -1 for the indeterminate
+     * "reading/listing" sub-phase; {@code message} is the current file line (may be empty).
+     */
+    public static InstallState extracting(int percent, String message) {
+        return new InstallState(Phase.EXTRACTING, Op.INSTALL, percent, "", message, 0L);
+    }
+
     public static InstallState provisioning(String message) {
         return new InstallState(Phase.PROVISIONING, Op.INSTALL, 0, "", message, 0L);
     }
 
@@ -106,6 +106,9 @@ protected void onCreate(Bundle savedInstanceState) {
         installStatus = findViewById(R.id.k2go_install_status);
         installBar = findViewById(R.id.k2go_install_bar);
         installDetail = findViewById(R.id.k2go_install_detail);
+        // ADFA-4915: extract detail is one middle-ellipsized line so long file names never overlap.
+        installDetail.setMaxLines(1);
+        installDetail.setEllipsize(android.text.TextUtils.TruncateAt.MIDDLE);
         installing = getIntent().getBooleanExtra(EXTRA_INSTALLING, false);
         // The Lottie has a text layer (OPEN/CLOSED sign). Use the system typeface (Noto-based,
         // global script fallback) so localized words render in any language; a TextDelegate maps
@@ -215,6 +218,24 @@ private void showInstallProgress(InstallState st) {
             installBar.setIndeterminate(false);
             installBar.setProgress(st.percent);
             installDetail.setText(st.percent + "%" + (st.speed.isEmpty() ? "" : "  ·  " + st.speed));
+        } else if (st.phase == InstallState.Phase.EXTRACTING) {
+            if (st.percent < 0) {
+                // ADFA-4915: "reading/listing" sub-phase. listEntries() scans the whole archive
+                // (~1 min; longer on low-end devices), so show an animated "reading …" + an
+                // indeterminate bar instead of a frozen 0%.
+                startReadingEllipsis(getString(R.string.k2go_reading));
+                installBar.setIndeterminate(true);
+                installDetail.setText("");
+            } else {
+                // ADFA-4915: determinate extract — real % plus just the current file's basename
+                // (no internal path, no counter): one ellipsized line that never overlaps.
+                installStatus.setText(org.iiab.controller.deploy.domain.ExtractProgress.firstLine(
+                        getString(R.string.install_status_extracting)));
+                installBar.setIndeterminate(false);
+                installBar.setProgress(st.percent);
+                String name = org.iiab.controller.deploy.domain.ExtractProgress.fileLabel(st.message);
+                installDetail.setText(name.isEmpty() ? (st.percent + "%") : (st.percent + "%  ·  " + name));
+            }
         } else {
             installStatus.setText(st.message.isEmpty() ? getString(R.string.k2go_setting_up_library) : st.message);
             installBar.setIndeterminate(true);
@@ -495,6 +516,29 @@ private void stopBootEllipsis() {
         ellipsisRunnable = null;
     }
 
+    /** ADFA-4915: animate "reading" + . / .. / … while the archive is being listed. Reuses the
+     *  ellipsis handler (boot and reading never run at once) without touching {@code bootBaseText}. */
+    private void startReadingEllipsis(final String base) {
+        stopBootEllipsis();
+        ellipsisRunnable = new Runnable() {
+            int i = 0;
+            final String[] frames = {"   ", ".  ", ".. ", "..."};   // 0..3 dots, fixed 3-slot width (monospace)
+            @Override public void run() {
+                if (installStatus != null) {
+                    String suffix = frames[i % frames.length];
+                    android.text.SpannableString sp = new android.text.SpannableString(base + " " + suffix);
+                    sp.setSpan(new android.text.style.TypefaceSpan("monospace"),
+                            base.length() + 1, base.length() + 1 + suffix.length(),
+                            android.text.Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+                    installStatus.setText(sp);
+                }
+                i++;
+                ellipsisHandler.postDelayed(this, 450L);
+            }
+        };
+        ellipsisHandler.post(ellipsisRunnable);
+    }
+
     @Override
     public void enableSystemProtection() {
         Intent i = new Intent(this, WatchdogService.class);
 
@@ -273,6 +273,8 @@
     <string name="k2go_step2b_info_courses">Courses — set up on the device after install.</string>
     <string name="k2go_step2b_info_review">Review your library, then download.</string>
     <string name="k2go_setting_up_library">Setting up your library…</string>
+    <!-- ADFA-4915: minimalist indicator during the archive "reading/listing" sub-phase. Technical term, not localized for now. -->
+    <string name="k2go_reading" translatable="false">reading</string>
     <string name="k2go_clone_hide_code">Hide code  ▴</string>
     <string name="k2go_clone_chooser_send_code">Send transfer code</string>
     <string name="k2go_clone_scan_prompt_receive">Scan the other phone\'s transfer code</string>
 
@@ -0,0 +1,52 @@
+package org.iiab.controller.deploy.domain;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class ExtractProgressTest {
+
+    @Test public void zeroWhenUnknownOrEmpty() {
+        assertEquals(0, ExtractProgress.percent(0, 0));
+        assertEquals(0, ExtractProgress.percent(10, 0));
+        assertEquals(0, ExtractProgress.percent(0, 100));
+        assertEquals(0, ExtractProgress.percent(-5, 100));
+    }
+
+    @Test public void midValuesRoundDown() {
+        assertEquals(50, ExtractProgress.percent(50, 100));
+        assertEquals(33, ExtractProgress.percent(1, 3));
+        assertEquals(68, ExtractProgress.percent(680, 1000));
+    }
+
+    @Test public void cappedAt99UntilComplete() {
+        assertEquals(99, ExtractProgress.percent(100, 100));
+        assertEquals(99, ExtractProgress.percent(999, 1000));
+        assertEquals(99, ExtractProgress.percent(5000, 1000));
+    }
+
+    @Test public void monotonicNonDecreasingForGrowingDone() {
+        int prev = 0;
+        for (long done = 0; done <= 1000; done += 37) {
+            int p = ExtractProgress.percent(done, 1000);
+            assertTrue("percent must not regress", p >= prev);
+            prev = p;
+        }
+    }
+
+    @Test public void firstLineTakesTextBeforeNewline() {
+        assertEquals("Extracting System...", ExtractProgress.firstLine("Extracting System...\n(This takes a while)"));
+        assertEquals("Solo una linea", ExtractProgress.firstLine("Solo una linea"));
+        assertEquals("", ExtractProgress.firstLine(null));
+        assertEquals("trimmed", ExtractProgress.firstLine("  trimmed  \nrest"));
+    }
+
+    @Test public void fileLabelIsBasenameFilesOnly() {
+        assertEquals("os.py", ExtractProgress.fileLabel("usr/lib/python3.11/os.py"));
+        assertEquals("foo", ExtractProgress.fileLabel("foo"));
+        assertEquals("", ExtractProgress.fileLabel("usr/lib/"));
+        assertEquals("", ExtractProgress.fileLabel(""));
+        assertEquals("", ExtractProgress.fileLabel(null));
+    }
+}