This post reviews every major SmartPerfetto change since the previous three-week update (2026-06-04, v1.0.28), through 2026-07-17 (v1.1.1). By the end, you will understand the problem each feature solved over these six weeks, where its boundaries lie, and the full feature map of the current release. Project repository: github.com/Gracker/SmartPerfetto.
Version note (reviewed October 2026): This retains the historical v1.1.1 scope at
d90cb888. “Current” and “these six weeks” refer to the period ending on July 17, 2026. Test numbers are historical records, not fresh runs. See the later v1.7.0 update; v1.16.1 adds further report-data and offline-interaction fixes. Original diagrams remain historical illustrations; corrected counts and boundaries below take precedence.
1. Overview of Changes (2026-06-04 to 2026-07-17)
The range v1.0.28..v1.1.1 contains 154 non-merge commits and release commits for 13 version numbers (v1.0.29 → v1.1.1). This review does not revalidate every distribution artifact for every version. If the main theme of the previous post was “getting all four Agent runtimes working,” this period focused on converging those four runtimes on one shared contract, while continuing to expand the analysis experience, scene knowledge, and public ecosystem.
The following counts use filename suffixes under backend/skills/ and backend/strategies/ at each Git tag:
| Metric | 2026-06-04 (v1.0.28) | 2026-07-17 (v1.1.1) |
|---|---|---|
Skill YAML (*.skill.yaml) |
230 | 239 |
Scene strategies (*.strategy.md) |
20 | 21 |
Strategy/prompt templates (*.template.md) |
35 | 80 |
| Perfetto upstream syncs | — | Three syncs during this period: v56.0 → v57.1 → v57.2 |
| Agent runtimes | 4 parallel implementations | 4, sharing a unified run specification |
The diagram’s “239 Skills” counts files, including the _base.skill.yaml template skipped by the loader. Excluding it leaves 238 non-template definition files, not a claim that every run registers, invokes, or successfully executes all definitions. The original v1.0.28 count of 226 has been corrected to 230 from the tag.
The sections below follow their impact on everyday analysis workflows, from largest to smallest. We will start with features that changed how SmartPerfetto is used—the dual-trace workspace and Quick Mode—then move to features that raised its capability ceiling, including private analysis context and runtime unification, before covering scenes, knowledge, the ecosystem, and engineering delivery.
2. Dual-Trace Analysis Workspace
Comparison is at the heart of performance optimization: before versus after a change, your product versus a competitor, or regression analysis after a system upgrade. SmartPerfetto already allowed an AI session to attach a reference trace, but the UI exposed only one timeline window. The most natural workflow—viewing two traces side by side—was not possible. The dual-window workspace, shipped on July 10–11 (v1.0.39), filled that gap.
The interaction path is deliberately short:
- Enter with one click: A direct “Open Dual Window” button sits at the top of the AI Panel. Clicking it immediately opens two windows: one showing the current trace and the other initially empty. Select a reference trace from the workspace history without first going through the trace picker.
- Atomic window identity swap: Both windows have trace selectors, so users can freely decide which window displays the current trace and which displays the reference trace. If a historical trace is selected in the current window, the current trace moves atomically to the other window. The workspace never shows the same trace in both windows or enters an intermediate state with no current trace.
- Run identity protection: During analysis, the “current trace + reference trace + Agent session” form a single run identity. Switching traces, exiting comparison mode, changing Providers, or changing workspaces is rejected while the run is active. Only an explicit Stop invokes the backend cancellation protocol. Layout changes, maximization, dragging, and collapsing the AI Panel affect presentation state only: they neither destroy the iframe nor transfer ownership of the streaming connection. The aim is to keep “I moved a window halfway through the analysis” from interrupting the task. This contract covers normal layout operations; crashes, network failures, and page unloads still require separate handling.
- Separate exit semantics: Exiting dual-window mode closes only the visual workspace; the reference trace and AI comparison context remain available. Exiting comparison mode additionally clears the reference trace, comparison context, and comparison session.
At the contract level, the smp compare CLI command and the frontend dual-window workspace use the same backend comparison identity, evidence package, and report section. Reusing that contract does not guarantee identical conclusions across different inputs, selected ranges, models, or samples. The product boundary is equally explicit: comparison always means “the current trace + one reference trace from workspace history.” Comparing any two arbitrary historical traces is not supported; that belongs to the domain of comparing multiple analysis results through snapshot comparison.
The v1.1.1 operation model documents the state machine and edge cases.
3. Quick Mode: Evidence-Backed Direct Answers and Analysis Receipts
Many everyday questions ask for straightforward facts: “What is the frame rate?”, “Which app is in the foreground?”, or “How severe is the jank?” Sending these questions through a full Agent loop—planning, multiple tool calls, and verification—is both slow and token-intensive. Over these six weeks, the fast path was rebuilt as a genuine evidence-backed direct-answer product. Analysis receipts became a product surface on June 29, the four runtimes were aligned on July 3, and v1.0.38 followed.
The flow has three steps:
- Intent recognition: A local classifier identifies direct-answer intents, including trace facts such as frame count, duration, processes, and threads; the foreground app; and an initial scrolling-smoothness assessment. It also handles mixed intents. For example, “What is the frame rate? Is it smooth overall?” matches both trace-fact and scrolling-assessment intents and combines the evidence for both in one answer.
- Deterministic evidence collection: The backend executes the corresponding SQL/Skill directly to collect evidence, bypassing the model’s tool-call loop.
- Direct-answer assembly: SmartPerfetto assembles the answer directly from evidence tables, adds sentence-level data citations, and returns it after zero model conversation turns. An analysis receipt at the end records which evidence was used and the state of the quality gates.
The original post records nine historical end-to-end cases using a DeepSeek configuration, including identity, compound facts, frame count and jank, scrolling triage, foreground app, CPU frequency, and English questions. Eight recorded zero model turns. A zero-turn case uses local assembly; it does not establish an actual DeepSeek request. The original run artifacts were not revalidated here, and historical claim-verifier passes do not establish correctness for arbitrary questions.
Two engineering details are worth calling out:
- Consistent behavior across all four runtimes. Direct-answer intent derivation, evidence assembly, and the contract governing the number of conclusions converged on shared modules across Claude, OpenAI, Pi Agent Core, and OpenCode. The Claude path had previously assembled these by hand and silently dropped scrolling evidence for mixed intents, diverging from the other three runtimes. Sharing the implementation reduces this source of drift. Contract values such as the maximum number of conclusions are now injected as template variables from a single source of truth.
- Bounded direct-answer scope. Direct answers cover only questions that deterministic evidence can resolve. Questions outside that scope, such as the open-ended request “Give me a quick analysis,” fall back to the normal Agent path instead of being forced into the direct-answer framework and receiving an incomplete answer.
The diagram’s zero-turn path requires a supported intent, available evidence, and a satisfied direct-answer contract. Classification can be wrong; missing data is not a zero measurement. Other fast requests can still call a model, so fast does not imply zero tokens.
4. Private Analysis Context: Local Source Code + the Android Internals Knowledge Base
A trace can show you where performance degrades, but explaining why often requires returning to source code and system internals. Over these six weeks, SmartPerfetto integrated two types of private context into the analysis pipeline and unified their authorization model in v1.1.0. This was the main reason for the version jump from 1.0 to 1.1.
Local source code (Code-Aware). A registered tree lets trace symbols be mapped to candidate classes, functions, and CodeRefs; source-version and device-build correspondence still need verification. In metadata_only, the model receives chunk IDs, relative paths, line ranges, and symbols. In provider_send, filtered snippets require both registration-time sendToProvider consent and the current run’s sending choice. The original “metadata only” claim applies to the first mode; see the versioned guide. A patch marked verified passed file-scope checks and git apply --check; that does not establish compilation, test success, or a performance fix.
External Android Internals knowledge base (July 14). A local checkout of android-internals-wiki can be registered as a versioned external knowledge source. The retrieval pipeline enforces the following constraints:
- Paths are denied by default. Only Markdown files under an environment-variable allowlist can be previewed and indexed.
- Registration requires confirmation of content rights (
rightsAcknowledged). Sending content to the model provider requires separate, revocable privacy consent (sendToProvider). Once revoked, new indexing and retrieval requests are rejected immediately. - Only strictly parsed
finalizedor legacyverifiedarticles enter retrieval. Drafts and articles awaiting review appear only in the audit trail. - The model receives only budget-controlled, redacted matching excerpts. Logs and streaming events expose metadata projections only.
- Wiki matches provide system background but cannot replace evidence from the current trace. Diagnostic conclusions must still cite actual SQL/Skill query results.
Combined semantics (v1.1.0). Source code and the knowledge base have independent authorization lists; either can be used alone or both can be combined. Whenever any private context is present, fast/auto mode is forced to resolve to full mode, where the necessary tools and evidence gates are available. Tenant, workspace, user, authorization list, index generation, content fingerprint, and consent state all contribute to a single authorization fingerprint. If any of these changes at a tool-call or run boundary, execution is rejected immediately—fail closed—rather than silently falling back to a different analysis mode. These are checks at tool and run boundaries, not retroactive recall: revocation cannot retrieve data already sent to a provider. Private analysis allows bounded in-process continuity, does not restore a persisted provider conversation, and disables cross-session pattern learning.
5. Unifying the Agent Runtime Architecture
This was the largest body of code changed during the six-week period, delivered in two stages.
The early-June refactoring (around v1.0.32, across more than twenty refactoring commits):
- The four runtimes moved into independent engine directories, while shared logic—including diagnostics, hypothesis projection, and runtime descriptors—moved into a common layer.
- Cancellation semantics were extended all the way down to the SQL tool layer. Stop removes queued work and aborts in-flight HTTP/RPC requests. This does not prove the remote Trace Processor’s internal SQL execution stops at the same instant.
- The two third-party runtimes, Pi Agent Core and OpenCode, regained resumability for opaque session state, allowing a restored session to continue with its previous context.
- Provider snapshots are bound to the runtime environment. Restoring a session cannot silently switch models merely because the user has changed the active Provider.
- The verifier’s misdiagnosis-pattern library is loaded from strategy files, so adding a new pattern no longer requires a TypeScript change.
The v1.1.0 consolidation on July 17: All four runtimes now consume the same Provider-independent run specification and comparison-context builder. Central option parsing reduces the risk that an option works on the Claude path but is ignored on the OpenAI path; runtime-specific regression coverage is still needed. The release also introduced reproducible Perfetto UI prebuild artifacts and a backend regression CI gate (backend-agent-regression-gate in GitHub Actions).
Before v1.1.0 shipped, the July 15 weekly review and July 16 clean-room review examined the release tree. The latter recorded no known P0/P1 blockers in its reviewed tree (report). Source-reference, tool-output, evidence-label, and scrolling-metric fixes belong to that v1.1.0 consolidation. Relative to v1.1.0, v1.1.1 contains the Docker OpenCode runtime-link normalization for the arm64 build path plus the version commit; the earlier review fixes should not all be attributed to v1.1.1.
6. Token Cost Optimization
In mid-June, we identified the largest source of token consumption in full mode: the methodology section of the system prompt embedded the entire scene strategy—estimated at approximately 51K tokens for the launch scene in the historical optimization report—and the existing prompt-budget mechanism trimmed only supporting sections, never this one. Each full launch analysis was effectively putting an entire “startup analysis textbook” into context; actual charges still depended on caching and pricing. A complete optimization package landed on June 18–19 in v1.0.35:
- Strategy split: Scene strategies are divided into core and detail layers. The core remains in the prompt and is limited to a few thousand tokens; detail is delivered on demand as the analysis advances through its stages. Quality requirements moved into expected tool-call lists in plan templates and into the verifier, to constrain evidence coverage; regression tests are still needed to assess any loss of analysis quality.
- Estimated-token baselines using real strategy files: New estimated-token baseline tests load the actual strategy files and cover the worst-case combination—scene + architecture + completeness + selection + comparison + source awareness all enabled at once—to prevent future changes from silently inflating prompt size again. The previous unit tests mocked the strategy loader and could not detect size regressions.
- Automatic summarization of large SQL results: SQL outputs above a threshold are summarized automatically, with retained data exposed through paginated artifact references; row limits, truncation, and artifact lifetime still apply.
- Compressed tool descriptions and cache boundaries: MCP tool descriptions were compressed across all four runtimes. Prompt-cache boundaries were added to the runtimes and are now selected according to capability flags declared by Provider adapters, rather than hardcoded Provider names.
The diagram’s 51K and these baselines are not universal tokenizer measurements or API billing values: this version’s estimatePromptTokens uses a character heuristic. Smaller input reduces context pressure; savings depend on actual usage, cache hits, and pricing. Pi and OpenCode are runtimes, and OpenAI-compatible is an interface category, so none establishes the absence of caching; for example, the OpenAI API supports Prompt Caching.
7. Expanded Scene Coverage: Camera, Heap, and GPU
All three new scenes follow the same principle: evidence first; when data is insufficient, say so explicitly instead of inventing a conclusion.
- Camera analysis (July 12): SmartPerfetto added an evidence-oriented camera capture preset, available directly through
smp capture, along with a camera-trace evidence Skill. The key design is conditional tracepoint availability. Tracepoints for different stages of the camera pipeline vary significantly across vendors and platform versions. The Skill first probes the current trace to determine which evidence sources exist, reaches conclusions only for stages backed by data, and explicitly marks data-starved stages as unavailable instead of forcing them through a template. - Heap dominator-path analysis (July 14): A new deterministic Skill clusters and extracts heap dominator paths. It extracts dominator paths from the managed heap graph, groups isomorphic paths into clusters, and answers, “Which reference chains are retaining this memory?” Batch trace runs automatically aggregate heap paths across traces and present the cross-trace distribution of memory clusters in the batch report, backed by regression cases using real heap-graph traces.
- GPU compute evidence (July 14): A vendor-neutral GPU compute evidence Skill that does not depend on proprietary counters from any specific GPU vendor, backed by real-trace regression coverage.
- Existing-scene hardening (early June): Memory-analysis evidence handling was hardened, and the evidence semantics for thread blocked reasons were corrected. The latter fixed incorrect attribution in the “blocked reason” field.
These capabilities have data limits. Heap analysis uses recorded managed-heap dumps and returns bounded dominator paths, not an exhaustive heap or a leak diagnosis. GPU analysis needs recorded compute events in gpu_slice/gpu_track and producer-supplied arguments. Vendor-neutral does not mean every Android trace contains them, and duration shares alone do not establish GPU utilization or a bottleneck.
8. RFC-0025: Eight AI Workflow Surfaces
Eight capabilities defined by RFC-0025 were merged on July 7. The goal was to extend AI analysis from a question-and-answer interaction into auditable, batch-oriented, collaborative workflows. Design and implementation documents live under docs/architecture/perfetto-ai-rfc-0025/ in the repository. The historical implementation record lists implemented scope, verification paths, and deferred capabilities.
| # | Capability | Description |
|---|---|---|
| 1 | Analysis receipts and evidence audits | Every analysis produces a structured receipt covering tool calls, evidence coverage, and quality-gate status, answering “What did this analysis do, and what evidence supports it?” |
| 2 | Capture-configuration recommendations | When analysis finds an evidence gap, it generates recommendations for the next trace capture: “Which data sources should I enable next time to verify this conclusion?” |
| 3 | UI navigation recommendation protocol | The AI emits structured timeline navigation recommendations—a timestamp or range—that users can click to apply; the AI never manipulates the UI directly |
| 4 | Similar-case retrieval for snapshots | MVP similarity retrieval across completed snapshots; navigation hints do not replace current-trace evidence |
| 5 | SQL query review layer | Adds a queryReview audit sidecar to executed SQL/Skill results, recording intent, tables/fields, filters, warnings, and artifact references |
| 6 | External Skill package extensions | Managed local-workspace Skill package import with hash checks; remote discovery, archive sync, and signatures were deferred |
| 7 | Batch trace lifecycle | Batch submission, concurrency control, progress tracking, and result aggregation; the heap-cluster aggregation report described earlier runs on this pipeline |
| 8 | AI capability controls and disclosure | Enterprise environments can disable AI entirely or turn off individual capabilities; failed capability-policy validation is rejected immediately (fail closed) |
The first Query IR milestone observes and annotates executed queries. It neither compiles a new query language nor lets model-authored JSON approve SQL. Execution gates remain separate, and audit metadata is not evidence by itself. Skill-package hashes establish integrity, not publisher trust or SQL safety.
9. Knowledge Foundation: Android 17 Rendering Pipelines and the Trace Case Corpus
- Android 17 rendering-pipeline knowledge sync (July 13): The project-maintained S01–S14 content under
docs/rendering_pipelines/is now synchronized from a source repository pinned to a specific commit (npm run sync:rendering-pipelines). Manual edits are prohibited, with hashes detecting drift from the pinned snapshot. These are not ordinary documentation files: rendering-pipeline detection, teaching mode, and some Skills read them directly at runtime throughdoc_path. They are therefore bundled into every distribution format, including the Docker image, whose previously missing copy was fixed as part of this work. - Trace case corpus (July 13–14): SmartPerfetto introduced the
Trace/catalog.jsoncorpus catalog contract and migrated all real traces into a directory-structured corpus. It also introduced deterministically constructed traces: scenarios such as binder I/O blocking, GPU load, and framework pipelines are represented as reproducibly generated synthetic traces, each with a file of expected conclusions. Scene regression coverage expanded from “six fixed traces” to “catalog-driven corpus regression.” Scenes supported by the existing framework can add cases through catalog registration.
The source is Gracker’s rendering_pipelines project pinned at 043074f775d03551b4f9d068b4296e70258b3571 (versioned catalog), not Google-certified documentation. This review confirmed that Choreographer and Build.java (API 37) at the cited AOSP android-17.0.0_r1 tag, and the kernel tag, are accessible. Successful import and matching hashes still do not validate every platform claim. The diagram’s corpus arrows represent test/evidence inputs, not automatic loading of every fixture into each analysis. New cases still require valid assets, metadata, and expected assertions; synthetic passes do not replace real-device coverage.
10. The Case Knowledge Platform and Self-Evolution V1
The first version of the Case Knowledge platform landed on June 20–22 (v1.0.36/37), with the goal of making analysis experience persistent and reusable:
- Curated case ingestion: Typical performance-problem cases can be organized into structured knowledge and retrieved for citation during analysis.
- Self-Evolution V1: Patterns confirmed during analysis can be captured as reusable knowledge entries. Hardening this pipeline accounted for most of the work: a research report and multiple rounds of independent review drove fixes for 14 gaps, including automatic confirmation scans for patterns, serialized writes to pattern storage to reduce concurrent overwrite on that path, and SQL-result persistence.
- Runtime memory-layer hardening: SmartPerfetto now records previously silent state such as Provider continuity breaks and CLI fallback sources. When something goes wrong, users can reconstruct which model was actually used and which fallback path the run took.
V1 here means case/pattern capture, distinct from the later strategy-evaluation and apply/revert product. A confirmed label still needs evidence review. Serialized writes address contention on that storage path, not every possible multiprocess conflict. Private source/RAG analysis disables cross-session learning as described above.
11. Ecosystem: Eight Repositories Form a Complete Path
SmartPerfetto is no longer an isolated project. Launched on July 14, the Android Performance Ecosystem connects eight repositories across instrumentation, capture, analysis, knowledge, and reproduction into a complete Android performance analysis path:
| Stage | Project | Role | Link |
|---|---|---|---|
| Navigation | Android Performance Ecosystem | Unified project map, handoff metadata, README navigation blocks, and drift checks | GitHub |
| Instrumentation | TraceFix | Injects app-side android.os.Trace sections at compile time so method execution is visible in traces |
GitHub |
| Capture and measurement | Perfetto Tools | Captures reproducible Perfetto traces and collects FPS or Simpleperf measurements | GitHub |
| Analysis | SmartPerfetto | AI-assisted Web UI, CLI, reports, sessions, comparison, and evidence workflows | GitHub |
| Agent analysis | Perfetto Skills | Portable Android/Linux/Chromium Perfetto analysis Skills for direct use by Agents such as Codex, Claude Code, and OpenCode | GitHub |
| Learning | Android Performance Blog | Articles, system internals, and case studies | AndroidPerformance.com |
| System knowledge | Android Internal Wiki | An alpha-stage Android system knowledge base covering App, Framework, Native, and Kernel mechanisms | Coming soon |
| Reproduction | Trace for Blog (SystraceForBlog) | Perfetto/Systrace case files used in articles for hands-on reproduction | GitHub |
The relationship between SmartPerfetto and Perfetto-Skills deserves a closer look. The two repositories evolve independently but share a portable analysis contract:
- Public Skill export system (July 11-12):
backend/skills/public-export.yamlexplicitly classifies every runtime asset. Portable workflows, SQL, methodology, and pipeline knowledge enter the public projection, while product-specific Provider, session, and streaming semantics remain in SmartPerfetto.npm run verify:public-skillsverifies the exported result. - Bidirectional impact review gate:
npm run check:perfetto-skills-impactchecks configured paths and change ranges for shared-contract impact—including Skills, strategies, evidence contracts, SQL services, pipeline knowledge, and export policies—and requires the author to explicitly record a coordination decision: sync required, sync not required, or deferred with a handoff link. This prompts coordination review; path rules and recorded decisions can still miss semantic drift. - Perfetto upstream syncs: This period included three upstream syncs (v56.0 → v57.1 → v57.2). Each followed the repository’s sync rules for merging the fork, refreshing the UI prebuild, and running scene regressions.
12. Engineering and Usability
- Real-path DeepSeek end-to-end verification: Agent SSE end-to-end tests now use the real DeepSeek API by default (
npm run verify:e2e:deepseekand scene-specific scripts underbackend/), with a manually triggered GitHub Actions workflow also available. A real path verifies provider behavior for tool-call formats and streaming chunks; passing mocks do not establish that integration. - Institutionalized review: Weekly architecture reviews are paired with clean-room reviews before releases, with reports committed under
docs/reviews/. Quick Mode, RFC-0025, and v1.1.0 all had independent review records before these major features shipped. - Usability fixes: Portable packages exclude runtime data (v1.0.33); macOS signing resources are staged correctly (v1.0.37); the launcher has a port fallback; Bedrock model IDs are normalized across regions; the OpenCode runtime is linked correctly inside Docker; and Agent turn budgets have been adjusted.
- Dependency maintenance: Core dependencies—including the Claude Agent SDK, OpenAI Agents, Pi Agent Core, and OpenCode SDK—have been upgraded continuously.
13. The Complete SmartPerfetto Feature Map
As of v1.1.1, SmartPerfetto’s complete feature map is organized into eight layers: “entry points → analysis → evidence and quality → knowledge → comparison and code awareness → output → extensibility and governance → distribution.”
| Layer | Feature | Description |
|---|---|---|
| Entry points | Perfetto UI AI Assistant | The forked Perfetto UI includes a built-in AI panel/sidebar/floating window, placing timeline inspection and AI analysis on the same screen |
| Smart Mode | Reconstructs the scene timeline of a mixed trace, then lets users drill into all scenes or an individual one (startup/scroll/click/navigation/ANR, and more) | |
| Selection-based quick questions | Select a timeline region or slice and ask questions against that selected context | |
| Dual-trace comparison workspace | Loads the current and historical traces side by side, allowing AI to compare them in real time within the same session | |
| CLI | smp run / ask / repl / capture / compare / report / query / skill / doctor, including Android capture presets and automatic post-capture analysis |
|
| HTTP + SSE API | /api/agent/v1/*, /api/traces/*, and /api/reports/* for integrations and the frontend |
|
| Batch analysis | Batch submission, concurrency control, and result aggregation, including aggregate reports for heap clusters | |
| Analysis | Three analysis modes | fast (lightweight direct answers) / full (complete planning + verification) / auto (semantic routing) |
| Quick Mode evidence-backed direct answer | Zero-round direct answers from deterministic evidence collection, with sentence-level data citations and an analysis receipt | |
| Scene strategies | 21 Markdown scene strategies (including the final report contract), with scene classification driven by frontmatter | |
| YAML Skill engine | 239 YAML files (including one template; atomic/composite/deep/modules/pipelines/comparison), with L1-L4 tiered results | |
| Rendering pipeline detection and guidance | Covers View, Compose, Flutter, WebView, game, and other pipeline types, with the project-maintained Android 17 series (S01-S14) available to the runtime | |
| Four Agent runtimes | claude-agent-sdk / openai-agents-sdk / pi-agent-core / opencode, with a unified run specification, MCP tool registry, and plan evidence log | |
| Provider management | Manages multiple Provider profiles in the UI, with runtime switching, session-level binding, and environment isolation | |
| Evidence and quality | DataEnvelope structured results | A self-describing table/chart contract rendered by the frontend from its schema and consumed by reports, snapshots, and the CLI |
| Evidence contracts and conclusion validation | Conclusions must be backed by Skill/SQL evidence; deterministic conclusions are validated individually, with process and thread identity resolution | |
| Report contract gates | Strategy frontmatter declares required report sections, and completeness is checked programmatically | |
| Validator and misdiagnosis pattern library | An independent validation pass in full mode, with misdiagnosis patterns loaded from strategy files | |
| SQL query review | Query audit sidecars and warnings, not a universal pre-execution correctness check | |
| Knowledge | Perfetto SQL/stdlib index | Schema and standard-library symbol indexes plus knowledge-query tools, regenerated with each upstream sync |
| Case Knowledge and self-evolution | Curated case ingestion plus automatic pattern extraction from confirmed analyses (V1) | |
| Android Internals external knowledge base | Registers a local wiki checkout as a versioned knowledge source, with dual consent, metadata projection, and fail-closed enforcement | |
| Trace case corpus | A Trace/catalog.json catalog contract for scene regressions across real and deterministically constructed traces |
|
| Comparison and code awareness | Raw trace comparison | The dual-window workspace plus CLI smp compare, using the same backend comparison identity and evidence bundle |
| Comparison across analysis results | Compares authorized completed snapshots; does not imply cross-tenant access | |
| Similar-case retrieval | Retrieves similar cases across analysis snapshots (MVP) | |
| Code-Aware source analysis | Registers local codebases and resolves symbols; metadata-only by default, with snippets permitted after dual consent; patch apply-check is not functional testing | |
| Output | Real-time SSE projection | Streams progress, conclusions, and UI navigation suggestions while keeping chat readable instead of burying it in raw SQL |
| HTML reports | Reports evidence, verification, and identity information within version-specific projection limits | |
| Analysis result snapshots | Persistent snapshots for later comparison, similar-case retrieval, and reinspection | |
| CLI Turn Artifacts | Session and report files under ~/.smartperfetto/ for scripted consumption |
|
| Extensibility and governance | External Skill packages | Managed local package import and hash checks; remote discovery/signatures remained deferred |
| Capture configuration suggestions | Derives trace capture configuration suggestions from gaps in an analysis | |
| UI navigation suggestions | Structured navigation suggestions from AI that execute only after user confirmation | |
| AI capability controls and disclosure | Disables AI globally or per capability, with fail-closed enforcement when policy validation fails | |
| Public Skill export | Explicitly classified exports to the public Perfetto-Skills repository, guarded by a bidirectional impact review gate | |
| Distribution | Docker Hub | Pin image 1.1.1 and host ports before starting (steps below); no host Node.js required |
| Portable packages | Windows/macOS/Linux packages bundling Node.js 24 and a pinned trace processor | |
| npm CLI | npm install -g @gracker/smartperfetto@1.1.1, exposing the smp / smartperfetto commands |
|
| Source | ./start.sh, using the committed prebuilt UI without building the Perfetto submodule |
14. Release Timeline
The original diagram labels v1.1.1 “Review Fixes”; its actual increment is the Docker fix below. The earlier review fixes were already in v1.1.0. Dates follow release commits, not simultaneous availability on every channel.
| Version | Date | Highlights |
|---|---|---|
| v1.0.29 | 2026-06-05 | Stronger evidence for memory analysis and corrected evidence semantics for thread blocking reasons |
| v1.0.30 | 2026-06-06 | Perfetto upstream sync to v56.0 |
| v1.0.31 | 2026-06-06 | Agent end-to-end verification moved to the real DeepSeek path |
| v1.0.32 | 2026-06-07 | Runtime engines organized into directories, end-to-end cancellation semantics, state continuation for third-party runtimes, and a validator misdiagnosis pattern library |
| v1.0.33 | 2026-06-07 | Runtime data excluded from portable packages |
| v1.0.34 | 2026-06-17 | DeepSeek trace analysis alignment and turn-budget adjustments |
| v1.0.35 | 2026-06-19 | Token optimizations shipped: strategy core/detail split, SQL summaries, compressed tool descriptions, and cache boundaries |
| v1.0.36 | 2026-06-22 | Case Knowledge platform + self-evolution V1 + memory-layer fixes |
| v1.0.37 | 2026-06-22 | Fixed signing resources for macOS portable packages |
| v1.0.38 | 2026-07-04 | Productized Quick Mode direct answers and analysis receipts, refreshed Provider presets, and Perfetto v57.1 |
| v1.0.39 | 2026-07-11 | RFC-0025’s eight AI workflow surfaces and the dual-trace workspace |
| v1.1.0 | 2026-07-17 | Unified analysis context and runtime architecture, private-context authorization fingerprints, Camera/Heap/GPU scenes, Android 17 rendering knowledge, trace corpus, public Skill export, regression-gate CI, and Perfetto v57.2 |
| v1.1.1 | 2026-07-17 | Normalized the Docker OpenCode runtime link for the arm64 build path |
15. Try It and Send Feedback
The instructions below reproduce v1.1.1; see its versioned quick start for prerequisites. For a new installation, choose a newer release and follow its own documentation.
- Docker: Install Docker Engine/Desktop and the Compose plugin, then obtain the v1.1.1 checkout below. Its
docker-compose.hub.ymlhardcodesimagetolatest; change it tow553000664/smartperfetto:1.1.1. For a local trial, replace the twoportsentries with127.0.0.1:3000:3000and127.0.0.1:10000:10000, retaining the default container ports. Then rundocker compose -f docker-compose.hub.yml pullfollowed bydocker compose -f docker-compose.hub.yml up -d. This version does not supportSMARTPERFETTO_DOCKER_TAG; setting that variable does not pin the image. - Portable packages: Select a complete platform archive from v1.1.1 Release for Windows x64, macOS arm64, or Linux x64, rather than a Source code archive. Packages include Node and runtime dependencies, not model weights or account credentials; provider configuration is still required. This historical macOS release is described as non-notarized, so later notarization claims do not apply.
- Terminal/scripts: Run
npm install -g @gracker/smartperfetto@1.1.1with host Node.js 24 LTS (>=24 <25). - Source: Git, Node.js 24, and network access for first-time dependency/Trace Processor downloads are required. The macOS/Linux/WSL shell commands below obtain the pinned checkout. Run
./start.shfor source startup; frontend development additionally needs the matching submodule and./scripts/start-dev.sh.
1 | git clone --branch v1.1.1 --depth 1 https://github.com/Gracker/SmartPerfetto.git |
After startup, open the local page, save/test/activate a provider, then load a trace. A successful /health response establishes liveness, not provider authentication or analysis acceptance.
For bug reports, include a shareable minimal trace, evidence locations (timestamp/process/thread), version and provider/runtime, and the difference between expected and actual conclusions. Before a public issue, confirm sharing rights and inspect the trace for sensitive content; use a sanitized reproduction description when the trace cannot be shared.
SmartPerfetto Discussion Group
The historical discussion-group QR code is retained below. It may have expired and does not establish that enrollment is currently open:
Use GitHub Issues for current bug reports; other contact information is on the About page.